219 lines
13 KiB
Python
219 lines
13 KiB
Python
"""隔离验证最新择时、首次系统停买恢复、关注入池与负净成本。"""
|
|
import unit_test_guard # noqa: F401
|
|
import copy
|
|
import datetime as dt
|
|
import unittest
|
|
from unittest.mock import patch
|
|
from contextlib import ExitStack
|
|
import test_risk_exit as base
|
|
from app.core import holding_performance, strategy_book as books, signal_rules
|
|
from app.services import timing_state, risk_exit, consensus_service, strategy_service, plan_feed
|
|
from app.repo import rotation_repo, pms_repo
|
|
|
|
|
|
class DirectionTests(unittest.TestCase):
|
|
setUp = base.ServiceTests.setUp
|
|
use = base.ServiceTests.use
|
|
insert = base.ServiceTests.insert
|
|
change = base.ServiceTests.change
|
|
state = base.ServiceTests.state
|
|
instructions = base.ServiceTests.instructions
|
|
fire = base.ServiceTests.fire
|
|
|
|
def setup_direction(self):
|
|
self.params.update(PMS_SIGNAL_RECOVERY_ENABLED=True, PMS_SIGNAL_RECOVERY_START_AT=base.START.isoformat())
|
|
self.use(consensus_service, 'state_map', lambda:{base.CODE:{'stance':'看多', 'phase':'趋势多'}})
|
|
self.use(consensus_service, 'nightly_map', lambda codes:{base.CODE:{'verdict':'SELL'}})
|
|
def clear(code, only_source=None):
|
|
with rotation_repo.locked('test-pause','test',{}) as m:
|
|
if only_source:
|
|
m[code]['sources'].pop(only_source, None)
|
|
if not m[code]['sources']: m.pop(code)
|
|
else: m.pop(code, None)
|
|
return {'ok':True, 'cleared':True}
|
|
self.use(strategy_service,'clear_buypause',clear)
|
|
return base.NOW + dt.timedelta(seconds=60)
|
|
|
|
def record(self, action, at, n=10, **changes):
|
|
return timing_state.record({**base.signal(n, at=at), 'action':action, **changes}, now=at)
|
|
|
|
def test_latest_direction_replaces_prior_buy_and_sell_in_event_order(self):
|
|
now = self.setup_direction()
|
|
buy = self.record('BUY',now)
|
|
sell = self.record('SELL',now+dt.timedelta(seconds=1),11)
|
|
self.assertEqual(timing_state.latest(base.CODE,now+dt.timedelta(seconds=2))['action'],'SELL')
|
|
self.assertIsNone(self.record('BUY',now,12))
|
|
con = consensus_service.assemble({'ts_code':base.CODE,'company_review':base.review()},
|
|
nightly={'verdict':'BUY'},tech_states=consensus_service.state_map(),now=now+dt.timedelta(seconds=2))
|
|
self.assertEqual(con['timing']['stance'],'看空')
|
|
self.assertEqual(consensus_service.hard_keys(con)['timing']['event']['key'],sell['key'])
|
|
self.assertNotEqual(buy['key'],sell['key'])
|
|
|
|
def test_new_direction_invalidates_old_async_result_with_same_plan(self):
|
|
from app.services import judge_async
|
|
now=self.setup_direction(); buy=self.record('BUY',now)
|
|
candidate={'hard_numbers':{'plan_basis':{'id':'unchanged'}}}
|
|
payload={'action':'OPEN','context':{},'hard_numbers':{}}
|
|
old=judge_async.identity(candidate,payload)
|
|
candidate['hard_numbers']['timing']={'event':buy}
|
|
self.assertNotEqual(judge_async.identity(candidate,payload),old)
|
|
same=judge_async.identity(candidate,payload)
|
|
candidate['qty']=1000
|
|
self.assertEqual(judge_async.identity(candidate,payload),same)
|
|
|
|
def test_original_expiry_and_cutover_cannot_be_extended(self):
|
|
now=self.setup_direction()
|
|
self.assertIsNone(self.record('BUY',base.START-dt.timedelta(seconds=1)))
|
|
self.assertIsNone(self.record('BUY',now,is_fallback='true'))
|
|
self.record('BUY',now,expires_at=(now+dt.timedelta(seconds=20)).isoformat())
|
|
self.assertEqual(set(timing_state.buy_map(now)),{base.CODE})
|
|
self.assertEqual(timing_state.buy_map(now+dt.timedelta(seconds=20)),{})
|
|
self.assertIsNone(timing_state.latest(base.CODE,now+dt.timedelta(days=1)))
|
|
parsed=signal_rules.parse_intraday({'is_fallback':'true'})
|
|
self.assertEqual(parsed['is_fallback'],'true')
|
|
self.assertEqual(signal_rules.parse_intraday({'confidence':'nan'})['confidence'],0)
|
|
|
|
def test_fresh_buy_supersedes_nightly_sell_but_expiry_returns_to_nightly(self):
|
|
now=self.setup_direction(); self.record('BUY',now)
|
|
row={'ts_code':base.CODE,'company_review':base.review()}
|
|
for at,expected in [(now,'看多'),(now+dt.timedelta(seconds=300),'看空')]:
|
|
con=consensus_service.assemble(row,nightly={'verdict':'SELL'},now=at,
|
|
tech_states=consensus_service.state_map(),flip_at=now.isoformat())
|
|
self.assertEqual(con['timing']['stance'],expected)
|
|
|
|
def test_first_stop_recovers_once_without_reopening_orders(self):
|
|
now=self.setup_direction(); self.fire()
|
|
strategy_service.pause_buy(base.CODE,reason='同一卖出信号',source='intraday')
|
|
event=self.record('BUY',now)
|
|
result=risk_exit.recover_on_buy(base.CODE,event,now=now)
|
|
self.assertTrue(result['recovered']); self.assertEqual(self.state()['phase'],'WATCH')
|
|
self.assertEqual(self.state()['count'],0); self.assertEqual(self.instructions(),[])
|
|
self.assertEqual(strategy_service.buypause_map(),{})
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
self.assertFalse(risk_exit.on_signal(base.signal(2),now=now)['accepted'])
|
|
self.assertEqual(risk_exit.on_signal(base.signal(3,at=now+dt.timedelta(seconds=1)),
|
|
now=now+dt.timedelta(seconds=1))['count'],1)
|
|
|
|
def test_manual_pause_global_halt_and_paused_strategy_never_auto_resume(self):
|
|
now=self.setup_direction(); self.fire();event=self.record('BUY',now)
|
|
for source in ['user','signal']:
|
|
strategy_service.pause_buy(base.CODE,reason='人工约束',source=source)
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
strategy_service.clear_buypause(base.CODE,only_source=source)
|
|
self.params['PMS_GLOBAL_BUY_HALT']=True
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
self.params['PMS_GLOBAL_BUY_HALT']=False
|
|
self.insert('pms_strategy',{'book_id':'original','strategy_id':'paused','ts_code':base.CODE,'status':'PAUSED'})
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
|
|
def test_two_sells_or_rating_downgrade_cannot_be_undone_by_buy(self):
|
|
now=self.setup_direction();self.fire();event=self.record('BUY',now)
|
|
self.reviews[base.CODE]['company_review']=base.review('中','b',1)
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
self.reviews[base.CODE]['company_review']=base.review()
|
|
self.fire(2)
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
self.assertNotEqual(self.state()['phase'],'WATCH')
|
|
|
|
def test_nonpassing_consensus_or_missing_review_keeps_pause(self):
|
|
now=self.setup_direction();self.fire();event=self.record('BUY',now)
|
|
self.reviews[base.CODE]['company_review']=None
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
self.reviews[base.CODE]['company_review']=dict(base.review(),overall='差',doubt_hard=True)
|
|
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
|
|
|
|
def test_failed_clear_rolls_back_recovery_audit_and_state(self):
|
|
now=self.setup_direction();self.fire();event=self.record('BUY',now)
|
|
before=copy.deepcopy(self.state())
|
|
self.use(strategy_service,'clear_buypause',lambda *a,**k:{'ok':False})
|
|
with self.assertRaises(RuntimeError):risk_exit.recover_on_buy(base.CODE,event,now=now)
|
|
self.assertEqual(self.state(),before)
|
|
self.assertIn(base.CODE,strategy_service.buypause_map())
|
|
rows=pms_repo.list_ledger(ts_code=base.CODE,limit=100)
|
|
self.assertFalse(any('buy_recovery' in (r.get('hard_numbers') or {}) for r in rows))
|
|
|
|
|
|
class PerformanceTests(unittest.TestCase):
|
|
def test_negative_net_cost_preserves_realized_profit(self):
|
|
row={'total_qty':100,'price':52.67,'price_ok':True}
|
|
lots=[{'qty':100,'open_price':48.29,'realized_pnl':0},
|
|
{'qty':0,'open_price':47.28,'realized_pnl':6797}]
|
|
result=holding_performance.calculate(row,lots)
|
|
self.assertEqual(result['profit'],7235)
|
|
self.assertEqual(result['net_cost'],-1968)
|
|
self.assertEqual(result['unrealized'],438)
|
|
self.assertIsNone(result['profit_pct']); self.assertTrue(result['cost_recovered'])
|
|
|
|
def test_missing_lots_quantity_or_price_does_not_report_zero(self):
|
|
row={'total_qty':100,'price':10,'price_ok':True}
|
|
for lots in [[],[{'qty':99,'open_price':9,'realized_pnl':0}],
|
|
[{'qty':100,'open_price':9,'realized_pnl':None}]]:
|
|
self.assertFalse(holding_performance.calculate(row,lots)['ready'])
|
|
result=holding_performance.calculate(dict(row,price_ok=False),
|
|
[{'qty':100,'open_price':9,'realized_pnl':0}])
|
|
self.assertFalse(result['ready']);self.assertIsNone(result['profit'])
|
|
|
|
def test_three_decimal_cost_is_not_rounded_before_profit(self):
|
|
result=holding_performance.calculate({'total_qty':1700,'price':50,'price_ok':True},
|
|
[{'qty':1700,'open_price':47.339,'realized_pnl':0}])
|
|
self.assertEqual(result['profit'],4523.7)
|
|
|
|
|
|
class GridTests(unittest.TestCase):
|
|
def test_automatic_grid_waits_for_consensus_and_manual_grid_keeps_user_rules(self):
|
|
from app.services import strategy_runner as runner, param_store, portfolio
|
|
for note, allowed, paused, expected in [
|
|
('自动挂载:网格',False,False,True),('自动挂载:网格',True,False,False),
|
|
('自动挂载:网格',True,True,True),('人工安排',False,False,False)]:
|
|
with self.subTest(note=note,allowed=allowed,paused=paused), ExitStack() as stack:
|
|
stack.enter_context(patch.object(param_store,'get_bool',return_value=True))
|
|
stack.enter_context(patch.object(param_store,'get_float',side_effect=lambda k,d:d))
|
|
stack.enter_context(patch.object(timing_state,'enabled',return_value=True))
|
|
stack.enter_context(patch.object(pms_repo,'active_strategies',return_value=[
|
|
{'strategy_id':'g','ts_code':base.CODE,'type':'GRID','note':note}]))
|
|
stack.enter_context(patch.object(portfolio,'positions_view',return_value={
|
|
'positions':[{'ts_code':base.CODE,'total_qty':100}], 'totals':{'scale':10000}}))
|
|
stack.enter_context(patch.object(runner,'_today',return_value=20261105))
|
|
stack.enter_context(patch.object(runner,'_macro_gate_active',return_value=False))
|
|
stack.enter_context(patch.object(runner,'_buypause_codes',return_value={base.CODE} if paused else set()))
|
|
check=stack.enter_context(patch.object(consensus_service,'holding_buy_consensus',
|
|
return_value=(allowed,{'consensus':{'reason':'测试三源'}})))
|
|
run=stack.enter_context(patch.object(runner,'_tick_grid'))
|
|
self.assertTrue(runner.tick(now=base.NOW,dry_run=True)['ok'])
|
|
self.assertEqual(run.call_args.args[-1],expected)
|
|
self.assertEqual(check.called,note.startswith('自动挂载'))
|
|
|
|
def test_distribution_reference_no_longer_independently_stops_grid(self):
|
|
from app.services import strategy_advisor as advisor
|
|
from unittest.mock import Mock
|
|
svc=Mock();out={'skipped':[],'resumed':[]}
|
|
with patch.object(timing_state,'enabled',return_value=True), \
|
|
patch.object(advisor,'handoff_ready',return_value=(False,'')):
|
|
advisor._tend_existing({'strategy_id':'g','type':'GRID','status':'ACTIVE','note':'自动挂载:网格'},
|
|
{'ts_code':base.CODE}, {'cls':advisor.CLS_DISTRIB},True,0,{}, {},set(),20261105,False,out,svc)
|
|
svc.pause_buy.assert_not_called();svc.clear_buypause.assert_not_called()
|
|
|
|
|
|
class WatchTests(unittest.TestCase):
|
|
def row(self,code,rank,manual=False):
|
|
return dict(ts_code=code,name='示例',score=100-rank,rank=rank,research_rank=rank,
|
|
bucket='main',verdict='关注',upside=.2,
|
|
user_candidate={'id':'watch-id','expires_on':'2099-01-01'} if manual else None)
|
|
|
|
def test_watch_survives_both_buckets_and_cap_without_changing_rank(self):
|
|
a=self.row('600001.SH',1); b=self.row('600002.SH',100,True)
|
|
plan={'main':[a], 'observe':[b], 'rank_axis':'quality'}
|
|
result=plan_feed.select_candidates(plan,top_n=1,include_observe=False,rank_by_upstream=True)
|
|
self.assertEqual([r['ts_code'] for r in result['items']],['600001.SH','600002.SH'])
|
|
|
|
def test_manual_watch_cannot_bypass_expiry_blacklist_or_display_qualification(self):
|
|
r=self.row('600002.SH',100,True)
|
|
for changes,kwargs in [({'user_required':True,'user_candidate':{'id':'a','expires_on':'2000-01-01'}},{}),
|
|
({},{'black':['600002.SH']}),({'verdict':'仅展示'},{'route_by_verdict':True})]:
|
|
result=plan_feed.select_candidates({'main':[dict(r,**changes)]},**kwargs)
|
|
self.assertEqual(result['items'],[])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|