241 lines
18 KiB
Python
241 lines
18 KiB
Python
|
|
"""4%网格、真实批次、报价边界及减持余量,所有仓储均为内存桩。"""
|
||
|
|
import unit_test_guard
|
||
|
|
import copy
|
||
|
|
import datetime as dt
|
||
|
|
import sys
|
||
|
|
import unittest
|
||
|
|
from contextlib import nullcontext
|
||
|
|
from pathlib import Path
|
||
|
|
from unittest.mock import patch
|
||
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||
|
|
from app.core import grid_inventory as core, execution_policy
|
||
|
|
from app.services import grid_inventory as service, strategy_runner as runner, strategy_service
|
||
|
|
from app.repo import pms_repo
|
||
|
|
from config.settings import settings
|
||
|
|
|
||
|
|
P = dict(center=47.18, lower=46.035, upper=52.823, step_pct=.04, per_lot=1600, max_capital=76358.11)
|
||
|
|
def strategy(params=None):
|
||
|
|
return dict(strategy_id='grid', ts_code='002979.SZ', type='GRID', status='ACTIVE', params=copy.deepcopy(params or P), state={})
|
||
|
|
def records(qty=1500, price=47.28):
|
||
|
|
parent = dict(instruction_id='buy',ts_code='002979.SZ',origin_type='strategy',origin_id='grid',side='buy',action='ADD',book_id='original',progress={'leg':'grid_buy:1'})
|
||
|
|
lot = dict(id=1,ts_code='002979.SZ',lot_type='ADD',qty=qty,open_price=price,instruction_id='buy',book_id='original')
|
||
|
|
return [lot], {'buy':parent}
|
||
|
|
def pos(qty=1500, avail=1600):
|
||
|
|
return dict(total_qty=qty+100,add_qty=qty,avail_qty=avail)
|
||
|
|
def evaluate(st, state, position, price, paused=False):
|
||
|
|
return runner._eval_grid(st,position,{'price':price},None,{'state':state,'notes':[],'buy_paused':paused})
|
||
|
|
|
||
|
|
class InventoryTests(unittest.TestCase):
|
||
|
|
def test_cost_is_booked_not_trigger(self):
|
||
|
|
snap=core.project(strategy(),*records());self.assertEqual(snap['filled_levels']['1']['price'],47.28)
|
||
|
|
self.assertEqual(snap['invested'],70920);self.assertEqual(snap['filled_levels']['1']['sell_target'],49.18)
|
||
|
|
def test_partial_and_unfilled_do_not_create_inventory(self):
|
||
|
|
self.assertEqual(core.project(strategy(),[],{})['invested'],0)
|
||
|
|
self.assertEqual(core.project(strategy(),*records(100))['invested'],4728)
|
||
|
|
def test_new_entry_and_exit_preserve_full_grid(self):
|
||
|
|
st=strategy();lots,parents=records();parents['buy']['progress'].update(grid_params=P,grid_entry=46.979,grid_exit=50.0)
|
||
|
|
result=core.project(st,lots,parents)['filled_levels']['1'];self.assertEqual(result['sell_target'],50)
|
||
|
|
self.assertEqual(result['entry_level'],46.979)
|
||
|
|
def test_migration_does_not_reinterpret_old_index(self):
|
||
|
|
lots,parents=records();parents['buy']['progress'].update(grid_params={**P,'step_pct':.02},grid_entry=46.979,grid_exit=47.922)
|
||
|
|
result=core.project(strategy(),lots,parents)['filled_levels']['1'];self.assertEqual(result['sell_target'],49.18);self.assertIsNone(result['entry_level'])
|
||
|
|
def test_price_correction_changes_minimum_exit(self):
|
||
|
|
self.assertEqual(core.project(strategy(),*records(price=48))['filled_levels']['1']['sell_target'],49.92)
|
||
|
|
def test_other_book_and_unknown_parent_fail_closed(self):
|
||
|
|
for field,value in [('book_id','micro30'),('instruction_id','unknown')]:
|
||
|
|
lots,parents=records();lots[0][field]=value
|
||
|
|
with self.assertRaises(ValueError):core.project(strategy(),lots,parents)
|
||
|
|
def test_foreign_add_and_unknown_cost_fail_closed(self):
|
||
|
|
lots,parents=records();parents['buy']['origin_id']='other'
|
||
|
|
with self.assertRaises(ValueError):core.project(strategy(),lots,parents)
|
||
|
|
for value in [0,-1,float('nan'),float('inf')]:
|
||
|
|
with self.assertRaises(ValueError):core.project(strategy(),*records(price=value))
|
||
|
|
def test_base_and_closed_lots_are_not_grid_inventory(self):
|
||
|
|
lots,parents=records();lots.extend([{**lots[0],'id':2,'lot_type':'BASE','instruction_id':'manual'}, {**lots[0],'id':3,'qty':0}])
|
||
|
|
self.assertEqual(len(core.project(strategy(),lots,parents)['filled_levels']),1)
|
||
|
|
def test_price_rounding_respects_direction(self):
|
||
|
|
self.assertEqual(core.price_tick(32.6248,sell=True),32.63);self.assertEqual(core.price_tick(31.372),31.37)
|
||
|
|
def test_service_requires_position_to_match_booked_lots(self):
|
||
|
|
lots,parents=records()
|
||
|
|
with patch.object(pms_repo,'list_lots',return_value=lots),patch.object(pms_repo,'get_instruction',side_effect=parents.get):
|
||
|
|
self.assertEqual(service.snapshot(strategy(),pos())['invested'],70920)
|
||
|
|
with self.assertRaises(ValueError):service.snapshot(strategy(),pos(qty=1600))
|
||
|
|
|
||
|
|
class EvaluationTests(unittest.TestCase):
|
||
|
|
def setUp(self):
|
||
|
|
self.st=strategy();self.state={**core.project(self.st,*records()),'last_band':6}
|
||
|
|
def test_leads_overdue_remainder_sells_without_new_crossing(self):
|
||
|
|
d=evaluate(self.st,self.state,pos(),51.87,paused=True)
|
||
|
|
self.assertEqual((d['qty'],d['limit_price']),(1500,49.18));self.assertEqual(self.state['filled_levels']['1']['qty'],1500)
|
||
|
|
def test_t_plus_one_retries_at_unchanged_price(self):
|
||
|
|
self.assertIsNone(evaluate(self.st,self.state,pos(avail=0),51.87))
|
||
|
|
self.assertEqual(evaluate(self.st,self.state,pos(avail=1500),51.87)['qty'],1500)
|
||
|
|
def test_partial_fill_then_cancel_sells_only_booked_remainder(self):
|
||
|
|
self.st['params']['per_lot']=1000
|
||
|
|
self.assertEqual(evaluate(self.st,self.state,pos(),51.87)['qty'],1000)
|
||
|
|
self.state.update(core.project(self.st,*records(qty=800)))
|
||
|
|
self.assertEqual(evaluate(self.st,self.state,pos(qty=800),51.87)['qty'],800)
|
||
|
|
def test_does_not_sell_base_or_borrow_another_lot(self):
|
||
|
|
self.state.update(core.project(self.st,*records(qty=300)));self.st['params']['per_lot']=1600
|
||
|
|
self.assertEqual(evaluate(self.st,self.state,pos(qty=300,avail=800),51.87)['qty'],300)
|
||
|
|
def test_fifo_lot_not_yet_ready_blocks_later_lot_sale(self):
|
||
|
|
self.state['filled_levels']['1']['sell_target']=53
|
||
|
|
self.state['filled_levels']['2']={'qty':100,'price':40,'sell_target':42,'lot_id':2}
|
||
|
|
self.assertIsNone(evaluate(self.st,self.state,pos(qty=1600),51.87))
|
||
|
|
def test_missing_target_and_excess_inventory_do_not_silently_disappear(self):
|
||
|
|
with self.assertRaises(ValueError):evaluate(self.st,self.state,pos(qty=100),51.87)
|
||
|
|
self.state['filled_levels']['1'].pop('sell_target')
|
||
|
|
with self.assertRaises(ValueError):evaluate(self.st,self.state,pos(),51.87)
|
||
|
|
def test_sifang_same_boundary_does_not_round_trip(self):
|
||
|
|
p=dict(center=31.39,lower=30.116,upper=32.825,step_pct=.04,per_lot=1000,max_capital=67730.61)
|
||
|
|
st=strategy(p);state={'last_band':1,'filled_levels':{},'invested':0}
|
||
|
|
d=evaluate(st,state,pos(0),31.37);self.assertEqual(d['grid_entry'],31.372);self.assertEqual(d['limit_price'],31.37)
|
||
|
|
lots,parents=records(1000,31.37);parents['buy']['progress'].update({k:d[k] for k in ['grid_entry','grid_exit','grid_params']})
|
||
|
|
state.update(core.project(st,lots,parents))
|
||
|
|
self.assertIsNone(evaluate(st,state,pos(1000,700),31.38))
|
||
|
|
sell=evaluate(st,state,pos(1000,700),32.63);self.assertEqual(sell['qty'],700);self.assertEqual(sell['limit_price'],32.63)
|
||
|
|
def test_paused_and_cap_limited_buys_do_not_become_inventory(self):
|
||
|
|
p=dict(center=10,lower=8,upper=12,step_pct=.04,per_lot=1000,max_capital=1)
|
||
|
|
for paused in [False,True]:
|
||
|
|
state={'last_band':3,'filled_levels':{},'invested':0}
|
||
|
|
self.assertIsNone(evaluate(strategy(p),state,pos(0),8.9,paused));self.assertEqual(state['filled_levels'],{})
|
||
|
|
def test_same_entry_is_not_bought_twice(self):
|
||
|
|
p=dict(center=10,lower=8,upper=12,step_pct=.04,per_lot=100,max_capital=10000)
|
||
|
|
state={'last_band':3,'filled_levels':{'x':{'qty':100,'entry_level':9.2,'sell_target':10,'price':9.1}},'invested':910}
|
||
|
|
self.assertIsNone(evaluate(strategy(p),state,pos(100),9.1))
|
||
|
|
def test_first_tick_resets_cursor_without_buy(self):
|
||
|
|
st=strategy(dict(center=10,lower=8,upper=12,step_pct=.04,per_lot=100,max_capital=10000));state={'filled_levels':{},'invested':0}
|
||
|
|
self.assertIsNone(evaluate(st,state,pos(0),9.1));self.assertEqual(state['last_band'],2)
|
||
|
|
|
||
|
|
class ProtectionTests(unittest.TestCase):
|
||
|
|
def test_buy_pause_read_error_is_unknown_not_clear(self):
|
||
|
|
with patch.object(strategy_service,'buypause_map',side_effect=RuntimeError('db')):
|
||
|
|
self.assertIsNone(runner._buypause_codes())
|
||
|
|
def test_invalid_pause_document_raises(self):
|
||
|
|
with patch.object(pms_repo,'get_param',return_value='[]'):
|
||
|
|
with self.assertRaises(ValueError):strategy_service.buypause_map()
|
||
|
|
def test_old_proposal_and_insufficient_inventory_cannot_emit(self):
|
||
|
|
st=strategy();dec=dict(side='sell',qty=1500,grid_params=P,grid_lot_id=1,limit_price=49.18)
|
||
|
|
with patch.object(pms_repo,'list_instructions',return_value=[]),patch.object(pms_repo,'get_position',return_value=pos()),patch.object(service,'snapshot',return_value=core.project(st,*records())):
|
||
|
|
runner._validate_grid_decision(st,dec)
|
||
|
|
for changes in [dict(grid_params={}),dict(qty=1600),dict(limit_price=49.17),dict(grid_lot_id=2)]:
|
||
|
|
with self.assertRaises(ValueError):runner._validate_grid_decision(st,{**dec,**changes})
|
||
|
|
def test_new_day_preserves_unfinished_t0_leg(self):
|
||
|
|
state={'day':20261106,'open_leg':{'dir':'long','qty':100,'entry':10}}
|
||
|
|
runner._roll_day(state,{},20261109);self.assertEqual(state['open_leg']['qty'],100)
|
||
|
|
def test_trail_failed_partial_and_t_plus_one_do_not_consume_target(self):
|
||
|
|
st={'strategy_id':'trail','ts_code':'600000.SH','type':'TRAIL','params':{'start_line':.03,'giveback':.05,'sell_ratio':.5}}
|
||
|
|
state={'armed':True,'high_water':12};position={'total_qty':1000,'avail_qty':100,'avg_cost':9}
|
||
|
|
ctx={'state':state,'notes':[]}
|
||
|
|
d=runner._eval_trail(st,position,{'price':11},dt.datetime(2026,11,9,10),ctx)
|
||
|
|
self.assertEqual(d['qty'],100);self.assertEqual(state['trail_due']['qty'],500)
|
||
|
|
state['pending']={'iid':'sell','leg':'trail_sell','qty':100}
|
||
|
|
with patch.object(runner,'_pending_terminal',return_value=(True,{'exec_qty':100})):
|
||
|
|
runner._reconcile(st,state,position)
|
||
|
|
self.assertEqual(state['trail_due']['qty'],400);self.assertNotIn('trail_fired_hw',state)
|
||
|
|
d=runner._eval_trail(st,{**position,'total_qty':900,'avail_qty':900},{'price':11.8},None,ctx)
|
||
|
|
self.assertEqual(d['qty'],400)
|
||
|
|
state['pending']={'iid':'sell2','leg':'trail_sell','qty':400}
|
||
|
|
with patch.object(runner,'_pending_terminal',return_value=(True,{'exec_qty':400})):
|
||
|
|
runner._reconcile(st,state,position)
|
||
|
|
self.assertEqual(state['trail_fired_hw'],12);self.assertNotIn('trail_due',state)
|
||
|
|
self.assertIsNone(runner._eval_trail(st,{**position,'total_qty':500,'avail_qty':500},{'price':11},None,ctx))
|
||
|
|
def test_sar_zero_fill_still_retries_same_day(self):
|
||
|
|
st={'strategy_id':'trail','ts_code':'600000.SH','type':'TRAIL','params':{'sar_line':10,'giveback':.05,'sell_ratio':.5}}
|
||
|
|
state={};position={'total_qty':1000,'avail_qty':1000,'avg_cost':11};ctx={'state':state,'notes':[]};now=dt.datetime(2026,11,9,10)
|
||
|
|
with patch.object(runner.param_store,'get_bool',return_value=True),patch.object(runner.param_store,'get_float',side_effect=lambda k,d:d):
|
||
|
|
self.assertEqual(runner._eval_trail(st,position,{'price':9},now,ctx)['qty'],1000)
|
||
|
|
state['pending']={'iid':'sell','leg':'trail_sar'}
|
||
|
|
with patch.object(runner,'_pending_terminal',return_value=(True,{'exec_qty':0})):runner._reconcile(st,state,position)
|
||
|
|
self.assertEqual(runner._eval_trail(st,position,{'price':9},now,ctx)['qty'],1000)
|
||
|
|
|
||
|
|
class MigrationTests(unittest.TestCase):
|
||
|
|
def setUp(self):
|
||
|
|
from test_trade_correction_strategy import StrategyCorrectionTests
|
||
|
|
from sqlalchemy import text
|
||
|
|
from app.db import session as db
|
||
|
|
from app.services import grid_migration as migration
|
||
|
|
self.migration, self.db = migration, db
|
||
|
|
self.use = StrategyCorrectionTests.use.__get__(self)
|
||
|
|
StrategyCorrectionTests.setUp(self)
|
||
|
|
with self.engine.begin() as conn:
|
||
|
|
conn.execute(text('CREATE TABLE migration_param (k TEXT PRIMARY KEY, v TEXT)'))
|
||
|
|
conn.execute(text("INSERT INTO migration_param VALUES ('PMS_AUTO_GRID_STEP_PCT','0.02')"))
|
||
|
|
self.use(migration.param_store, 'get', lambda k,d=None: {'PMS_MONITOR_WATCH_SCOPE':'pms-sim-155','PMS_DISPATCH_MODE':'ws'}.get(k,d))
|
||
|
|
self.use(migration.param_store, 'get_bool', lambda k,d=False: False)
|
||
|
|
self.use(migration.param_store, 'get_float', lambda k,d=0: float(db.fetch_one('SELECT v FROM migration_param WHERE k=:k', {'k':k})['v']))
|
||
|
|
self.use(pms_repo, 'get_param', lambda k: db.fetch_one('SELECT v FROM migration_param WHERE k=:k', {'k':k})['v'])
|
||
|
|
def set_param(k,v,updated_by=''):
|
||
|
|
db.execute('UPDATE migration_param SET v=:v WHERE k=:k', {'k':k,'v':str(v)})
|
||
|
|
return {'ok':True}
|
||
|
|
self.use(migration.param_store, 'set_param', set_param)
|
||
|
|
self.use(migration.execution_orders, 'code_settlement_blocker', lambda code: '')
|
||
|
|
self.use(migration.execution_orders, 'replacement_state', lambda iid: {'ready':True})
|
||
|
|
def preview(self): return self.migration.migrate(['GRID'])
|
||
|
|
def apply(self, expected): return self.migration.migrate(['GRID'], apply=True, expected=expected)
|
||
|
|
def test_preview_is_readonly_and_commit_is_idempotent(self):
|
||
|
|
before=pms_repo.get_strategy('GRID'); preview=self.preview()
|
||
|
|
self.assertEqual(pms_repo.get_strategy('GRID'),before)
|
||
|
|
result=self.apply(preview['fingerprint']);self.assertTrue(result['applied'])
|
||
|
|
current=pms_repo.get_strategy('GRID');self.assertEqual(current['params']['step_pct'],.04)
|
||
|
|
self.assertEqual(float(pms_repo.get_param('PMS_AUTO_GRID_STEP_PCT')),.04)
|
||
|
|
self.assertIsNone(current['state']['last_band']);self.assertTrue(self.apply('obsolete')['already_applied'])
|
||
|
|
self.assertEqual(current,pms_repo.get_strategy('GRID'))
|
||
|
|
def test_audit_failure_rolls_back_strategies_and_runtime_default(self):
|
||
|
|
before=pms_repo.get_strategy('GRID');preview=self.preview()
|
||
|
|
with patch.object(self.migration.rotation_repo,'put_once',side_effect=RuntimeError('audit failed')):
|
||
|
|
with self.assertRaises(RuntimeError):self.apply(preview['fingerprint'])
|
||
|
|
self.assertEqual(before,pms_repo.get_strategy('GRID'))
|
||
|
|
self.assertEqual(float(pms_repo.get_param('PMS_AUTO_GRID_STEP_PCT')),.02)
|
||
|
|
self.assertIsNone(self.migration.rotation_repo.get(self.migration.KEY)[0])
|
||
|
|
def test_changed_strategy_and_wrong_target_set_fail_closed(self):
|
||
|
|
preview=self.preview();pms_repo.update_strategy('GRID',note='concurrent edit')
|
||
|
|
with self.assertRaisesRegex(ValueError,'预览后'):self.apply(preview['fingerprint'])
|
||
|
|
with self.assertRaises(ValueError):self.migration.migrate(['OTHER'])
|
||
|
|
def test_live_parent_blocks_migration(self):
|
||
|
|
with patch.object(pms_repo,'list_instructions',return_value=[{'instruction_id':'LIVE'}]):
|
||
|
|
with self.assertRaisesRegex(ValueError,'在途'):self.preview()
|
||
|
|
def test_unsettled_cancel_and_correction_hold_block_migration(self):
|
||
|
|
pms_repo.update_strategy('GRID',state={'pending':{'iid':'OLD'}})
|
||
|
|
with patch.object(pms_repo,'get_instruction',return_value={'status':'CANCELLED'}),patch.object(self.migration.execution_orders,'replacement_state',return_value={'ready':False}):
|
||
|
|
with self.assertRaisesRegex(ValueError,'结算'):self.preview()
|
||
|
|
pms_repo.update_strategy('GRID',state={'correction_hold':'qty'})
|
||
|
|
with self.assertRaisesRegex(ValueError,'更正'):self.preview()
|
||
|
|
def test_enabled_runner_and_wrong_instance_cannot_apply(self):
|
||
|
|
preview=self.preview()
|
||
|
|
with patch.object(self.migration.param_store,'get_bool',return_value=True):
|
||
|
|
with self.assertRaises(ValueError):self.apply(preview['fingerprint'])
|
||
|
|
with patch.object(settings,'PMS_TABLE_PREFIX','real_'):
|
||
|
|
with self.assertRaises(ValueError):self.preview()
|
||
|
|
def test_failed_parameter_write_rolls_back(self):
|
||
|
|
preview=self.preview();before=pms_repo.get_strategy('GRID')
|
||
|
|
with patch.object(self.migration.param_store,'set_param',return_value={'ok':False}):
|
||
|
|
with self.assertRaises(RuntimeError):self.apply(preview['fingerprint'])
|
||
|
|
self.assertEqual(before,pms_repo.get_strategy('GRID'))
|
||
|
|
|
||
|
|
class AdditionalBoundaryTests(unittest.TestCase):
|
||
|
|
def test_missing_pending_parent_does_not_clear_state(self):
|
||
|
|
state={'pending':{'iid':'missing'}}
|
||
|
|
with patch.object(pms_repo,'get_instruction',return_value=None):
|
||
|
|
with self.assertRaises(ValueError):runner._reconcile({'type':'GRID'},state,{})
|
||
|
|
self.assertEqual(state['pending']['iid'],'missing')
|
||
|
|
def test_geometry_and_per_lot_revalidated_before_buy(self):
|
||
|
|
prm=dict(center=10,lower=8,upper=12,step_pct=.04,per_lot=100,max_capital=10000)
|
||
|
|
st=strategy(prm);d=evaluate(st,{'last_band':3,'filled_levels':{},'invested':0},pos(0),9.1)
|
||
|
|
with patch.object(pms_repo,'list_instructions',return_value=[]),patch.object(service,'snapshot',return_value={'filled_levels':{},'invested':0}),patch.object(pms_repo,'get_position',return_value=pos(0)),patch.object(runner,'_buypause_codes',return_value=set()),patch.object(runner,'_macro_gate_active',return_value=False):
|
||
|
|
runner._validate_grid_decision(st,d)
|
||
|
|
for fields in [{'qty':200},{'grid_entry':9.1},{'grid_exit':9.3},{'limit_price':9.21}]:
|
||
|
|
with self.assertRaises(ValueError):runner._validate_grid_decision(st,{**d,**fields})
|
||
|
|
def test_empty_geometry_does_not_attach_idle_grid(self):
|
||
|
|
from app.services.strategy_advisor import grid_params
|
||
|
|
params,why=grid_params(price=10,support=9.99,pressure=10.01,band=.08,step_pct=.04,cap_room=10000,cap_ratio=.5)
|
||
|
|
self.assertIsNone(params);self.assertIn('完整',why)
|
||
|
|
def test_rejected_trail_proposal_does_not_repeat_same_trigger(self):
|
||
|
|
st={'type':'TRAIL','ts_code':'600000.SH','params':{'sar_line':10,'giveback':.05,'sell_ratio':1}}
|
||
|
|
state={'pending':{'pid':'p'},'trail_due':{'qty':100,'leg':'trail_sar','high_water':11}}
|
||
|
|
with patch.object(runner,'_today',return_value=20261109),patch.object(pms_repo,'get_proposal',return_value={'status':'REJECTED'}),patch.object(runner.param_store,'get_bool',return_value=True),patch.object(runner.param_store,'get_float',side_effect=lambda k,d:d):
|
||
|
|
self.assertTrue(runner._reconcile(st,state,{}))
|
||
|
|
self.assertIsNone(runner._eval_trail(st,{'total_qty':100,'avail_qty':100,'avg_cost':11},{'price':9},dt.datetime(2026,11,9,10),{'state':state}))
|
||
|
|
|
||
|
|
if __name__=='__main__':unittest.main()
|