"""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()