tradingSystem/scripts/test_signal_recovery.py

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