213 lines
13 KiB
Python
213 lines
13 KiB
Python
"""盘中名单的凭据、窗口、席位和最终出口。所有业务数据使用内存桩。"""
|
|
import unit_test_guard # noqa: F401
|
|
import datetime as dt
|
|
from contextlib import ExitStack, nullcontext
|
|
from unittest import TestCase, main
|
|
from unittest.mock import patch
|
|
from test_batch56_units import snapshot
|
|
from app.core import micro_rotation as core
|
|
from app.services import execution_orders as eo, intraday_rotation as entry
|
|
|
|
|
|
buy_ban = entry.repo.buy_ban
|
|
|
|
|
|
class IntradayEntry(TestCase):
|
|
def setUp(self):
|
|
self.stack = ExitStack()
|
|
self.addCleanup(self.stack.close)
|
|
self.now = entry.local_now(dt.datetime(2026, 11, 19, 10, 14))
|
|
self.day = self.now.date().isoformat()
|
|
self.basket = snapshot(self.day)
|
|
self.morning = dict(self.basket, snapshot_version='morning', basket_ready=False)
|
|
self.basket.update(frozen=False, basis='manual_intraday', authorization='auth1', morning_version='morning')
|
|
self.codes = [r['code'] for r in self.basket['members']]
|
|
self.release = dict(authorization='auth2', command_id='cmd', ticket='ticket', deadline=self.day,
|
|
snapshot_version=self.basket['snapshot_version'], rule_version=core.EXECUTION_RULE,
|
|
released_at=self.now.isoformat(), expires_at=self.now.replace(hour=15,minute=0).isoformat(),
|
|
funding_sales=True)
|
|
self.lines = [dict(code=c, id='PARENT'+c, side='buy',qty=100) for c in self.codes[:44]]
|
|
self.docs = {entry.release_key(self.day): self.release, 'intraday-basket:155:'+self.day: self.basket,
|
|
'auth2':dict(actor='user',account='155模拟', effective_date=self.day,rule_version=core.EXECUTION_RULE,
|
|
expires_at=self.release['expires_at'],funding_sales=True,revision={'replaces':'auth1'}),
|
|
'ticket':dict(id='ticket',source_auth='auth2',source_version=self.basket['snapshot_version'],
|
|
expires_at=self.release['expires_at'], no_carry=True,book='micro30',lines=self.lines),
|
|
'state:live':{'rotation':{'phase':'entering_micro','consumed_entry':self.basket['snapshot_version'],
|
|
'target':self.codes}}}
|
|
self.cfg = dict(mode='auto',control='run',rule_version=core.EXECUTION_RULE,candidate_pool_size=100)
|
|
self.mock(entry.settings,'PMS_TABLE_PREFIX','')
|
|
self.mock(entry.settings,'INFRA_STRATEGY_BOOK_SCHEMA',True)
|
|
self.mock(entry.store,'get',side_effect=lambda k:(self.docs.get(k),1))
|
|
self.mock(entry.param_store,'get_bool',return_value=True)
|
|
self.mock(entry.param_store,'execution_controls',return_value=dict(halt_all=False,halt_buy=False,control='run',mode='auto'))
|
|
self.cmd=dict(params=dict(self.release), status='EXECUTING', issued_by='user',cmd_type='ROTATE_MICRO')
|
|
self.mock(entry.pms_repo,'get_command',return_value=self.cmd)
|
|
self.parent=dict(instruction_id='p',status='DISPATCHED',book_id='micro30',side='buy',ts_code=self.codes[0],
|
|
qty=100,exec_qty=0,progress=entry.metadata(self.release))
|
|
self.order=dict(instruction_id='child',parent_id='p',ts_code=self.codes[0],side='buy',qty=100,
|
|
valid_until=int((self.now+dt.timedelta(minutes=1)).timestamp()*1000))
|
|
self.other = self.mock(entry.pms_repo,'list_instructions',return_value=[self.parent])
|
|
self.ban = self.mock(entry.repo,'buy_ban',return_value=False)
|
|
|
|
def mock(self, obj, key, *args, **kwargs):
|
|
return self.stack.enter_context(patch.object(obj,key,*args,**kwargs))
|
|
|
|
def test_fifty_targets_preserve_original_ids(self):
|
|
release, basket, lines = entry.basket_for(self.now,self.morning,self.cfg)
|
|
rotation = core.transition(core.initial_state(),basket,micro_qty=0,original_qty=0,budget=500000)
|
|
pending = [dict(ts_code=c) for c in lines]
|
|
core.resolve_targets(rotation,basket,pending=pending)
|
|
self.assertEqual(len(rotation['target']),50)
|
|
intents,_ = core.orders(rotation,basket,original=[],micro=[],pending=pending,cash=500000,account_mv=0,
|
|
cap_amount=500000,quotes={c:{'price':10} for c in self.codes[44:]})
|
|
self.assertEqual({i['ts_code'] for i in intents},set(self.codes[44:]))
|
|
self.assertFalse(basket['frozen'])
|
|
self.assertTrue(self.morning['frozen'])
|
|
self.assertEqual([lines[c]['id'] for c in self.codes[:44]],[r['id'] for r in self.lines])
|
|
|
|
def test_no_release_or_wrong_instance(self):
|
|
self.mock(entry.settings,'PMS_TABLE_PREFIX','real_')
|
|
self.assertIsNone(entry.basket_for(self.now,self.morning,self.cfg))
|
|
self.mock(entry.settings,'PMS_TABLE_PREFIX','')
|
|
del self.docs[entry.release_key(self.day)]
|
|
self.assertIsNone(entry.basket_for(self.now,self.morning,self.cfg))
|
|
|
|
def test_revised_or_corrupt_snapshot(self):
|
|
self.basket['members'][0]['close'] = 1
|
|
with self.assertRaises(ValueError):
|
|
entry.basket_for(self.now,self.morning,self.cfg)
|
|
|
|
def test_trading_sessions_and_expiry(self):
|
|
for h,m,allowed in [(9,29,False),(10,0,True),(11,30,False),(13,0,True),(14,57,False),(15,0,False)]:
|
|
self.assertEqual(entry.session_open(self.now.replace(hour=h,minute=m)),allowed)
|
|
self.assertIsNone(entry.read_release(self.now.replace(hour=15)))
|
|
|
|
def test_wire_freeze_then_sell(self):
|
|
self.mock(eo,'account_guard',side_effect=nullcontext)
|
|
self.mock(eo.qmt_repo,'get_order',return_value=self.order)
|
|
self.mock(eo.pms_repo,'get_instruction',return_value=self.parent)
|
|
self.mock(eo,'correction_blocker',return_value='')
|
|
self.mock(eo.policy,'local_now',return_value=self.now)
|
|
mark=self.mock(eo.qmt_repo,'mark_send_attempt',return_value=True)
|
|
self.ban.return_value=True
|
|
self.assertFalse(eo.prepare_send('child')['marked'])
|
|
mark.assert_not_called()
|
|
self.order['side']='sell'
|
|
self.parent.update(book_id='original',side='sell')
|
|
self.assertTrue(eo.prepare_send('child')['marked'])
|
|
self.cmd['progress']={'cancel_requested':True}
|
|
self.assertFalse(eo.prepare_send('child')['marked'])
|
|
self.cmd['progress']={}
|
|
self.cmd['status']='CANCELLED'
|
|
self.assertFalse(eo.prepare_send('child')['marked'])
|
|
self.assertEqual(mark.call_count,1)
|
|
|
|
def test_duplicate_or_partial(self):
|
|
self.other.return_value=[self.parent,dict(instruction_id='other')]
|
|
self.assertIn('其他指令',entry.blocker(self.parent,self.order,self.now))
|
|
self.other.return_value=[self.parent]
|
|
self.parent['exec_qty']=60
|
|
self.assertIn('余量',entry.blocker(self.parent,self.order,self.now))
|
|
self.order['qty']=40
|
|
self.assertFalse(entry.blocker(self.parent,self.order,self.now))
|
|
|
|
def test_replace_writes_only_own_book_before_cancel(self):
|
|
from app.core import strategy_book as books
|
|
from app.services import dispatcher
|
|
self.mock(eo,'account_guard',side_effect=nullcontext)
|
|
self.mock(eo.pms_repo,'get_instruction',return_value=self.parent)
|
|
writes=[]
|
|
def save(iid,progress):
|
|
sql = books.scoped_sql("UPDATE pms_instruction SET progress_json=:progress WHERE instruction_id=:iid")
|
|
writes.append(sql)
|
|
self.assertIn('replacement_requested',progress)
|
|
return 1
|
|
self.mock(eo.pms_repo,'update_instruction',side_effect=save)
|
|
cancel=self.mock(dispatcher,'cancel',return_value={'ok':True})
|
|
self.mock(eo,'replacement_state',return_value={'ready':False})
|
|
result=eo.request_replace('p','报价过期',self.now)
|
|
self.assertFalse(result['ready'])
|
|
self.assertIn("book_id = 'micro30'",writes[0])
|
|
cancel.assert_called_once()
|
|
self.parent['book_id']='unknown'
|
|
with self.assertRaises(ValueError):
|
|
eo.request_replace('p','报价过期',self.now)
|
|
self.assertEqual(cancel.call_count,1)
|
|
|
|
def test_standing_order_waits_at_qmt_despite_stale_quote_and_partial_fill(self):
|
|
from app.services import rotation_day_orders as day, rotation_execution as trade
|
|
self.parent['progress'].update(execution_profile='rotation')
|
|
self.parent['status']='DISPATCHED'
|
|
self.parent['exec_qty']=40
|
|
self.docs['qmt-day-orders:ticket']={'binding':entry.metadata(self.release),'account':'155模拟',
|
|
'lines':{'p':dict(ts_code=self.codes[0],book_id='micro30',side='buy',qty=100,price='10.00',source_ref='p')}}
|
|
self.mock(day.store,'account_guard',side_effect=nullcontext)
|
|
self.mock(entry.pms_repo,'get_instruction',return_value=self.parent)
|
|
self.mock(entry,'local_now',return_value=self.now)
|
|
history=self.mock(day.qmt_repo,'orders_for_parent',return_value=[dict(status='PARTIAL')])
|
|
send=self.mock(trade,'send_intent',side_effect=AssertionError('重复发单'))
|
|
cancel=self.mock(eo,'request_replace',side_effect=AssertionError('无依据撤换'))
|
|
work=dict(day=self.day,parents=[('micro30','p')],unavailable={},limits={})
|
|
self.assertEqual(day.execute(work),([],[]))
|
|
self.assertEqual(trade.refresh_orders([self.parent],{},self.now,self.basket['snapshot_version'],set(self.codes),{}),([],[]))
|
|
history.return_value=[dict(status='CANCELLED',cancel_state='NONE')]
|
|
self.assertIn('重新授权',day.execute(work)[1][0])
|
|
send.assert_not_called()
|
|
cancel.assert_not_called()
|
|
|
|
def test_standing_price_serializes_to_day_end_with_only_remaining_quantity(self):
|
|
from app.services import rotation_execution as trade, dispatcher
|
|
from app.core import ws_codec
|
|
self.parent.update(limit_price=10,qty=1000,exec_qty=400,origin_id='P_p',progress=dict(self.parent['progress'],children=[]))
|
|
line=dict(ts_code=self.codes[0],book_id='micro30',side='buy',qty=1000,price='10.00',source_ref='p')
|
|
self.docs['qmt-day-orders:ticket']=dict(binding=entry.metadata(self.release),account='155模拟',lines={'p':line})
|
|
self.mock(trade.db,'transaction',side_effect=nullcontext)
|
|
self.mock(eo,'code_settlement_blocker',return_value=None)
|
|
self.mock(eo,'replacement_state',return_value=dict(ready=True,remaining=600))
|
|
self.mock(eo,'retry_reason',return_value='')
|
|
self.mock(eo,'next_child_id',return_value='p_D02')
|
|
self.mock(entry.pms_repo,'get_instruction',return_value=self.parent)
|
|
self.mock(entry.pms_repo,'update_instruction',return_value=1)
|
|
self.mock(dispatcher,'mode',return_value='ws')
|
|
self.mock(entry,'local_now',return_value=self.now)
|
|
wire=[]
|
|
def dispatch(**kwargs):
|
|
kwargs.pop('parent_id')
|
|
kwargs['valid_until']=int(kwargs['valid_until'].timestamp()*1000)
|
|
wire.append(ws_codec.place_order_payload(**kwargs))
|
|
return {'ok':True}
|
|
self.mock(dispatcher,'dispatch',side_effect=dispatch)
|
|
intent=dict(id='p',ts_code=self.codes[0],side='buy',book_id='micro30',qty=1000,reason='盘中建仓',
|
|
day_limits=dict(up_limit=11,down_limit=9),limits_date=self.day)
|
|
trade.send_intent(intent,0,self.now,self.release['snapshot_version'])
|
|
self.assertEqual(wire[0]['qty'],600)
|
|
self.assertEqual(wire[0]['limit_price'],10.)
|
|
self.assertEqual(wire[0]['valid_until'],int(dt.datetime.fromisoformat(self.release['expires_at']).timestamp()*1000))
|
|
intent['day_limits']['up_limit']=9.5
|
|
with self.assertRaises(ValueError):
|
|
trade.send_intent(intent,0,self.now,self.release['snapshot_version'])
|
|
self.assertEqual(len(wire),1)
|
|
|
|
def test_standing_cancel_keeps_user_controls(self):
|
|
from app.services import rotation_day_orders as day
|
|
rot=self.docs['state:live']['rotation']
|
|
controls=dict(halt_all=False,halt_buy=False,mode='auto',control='run')
|
|
self.assertFalse(day.cancel_reason(self.parent,self.release,rot,controls))
|
|
self.ban.return_value=True
|
|
self.assertIn('冻结',day.cancel_reason(self.parent,self.release,rot,controls))
|
|
self.parent.update(side='sell',book_id='original')
|
|
self.assertFalse(day.cancel_reason(self.parent,self.release,rot,controls))
|
|
self.assertIn('撤销',day.cancel_reason(self.parent,None,rot,controls))
|
|
self.assertIn('暂停',day.cancel_reason(self.parent,self.release,rot,dict(controls,halt_all=True)))
|
|
|
|
def test_ban_removal_does_not_remove_other_ban(self):
|
|
rows=self.mock(entry.repo.db,'fetch_all',return_value=[{'cmd_type':t} for t in
|
|
('UNFREEZE_STOCK','BLACKLIST_ADD','FREEZE_STOCK')])
|
|
self.assertTrue(buy_ban(self.codes[0]))
|
|
rows.return_value.insert(0,{'cmd_type':'BLACKLIST_REMOVE'})
|
|
self.assertFalse(buy_ban(self.codes[0]))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|