tradingSystem/scripts/test_timing_fusion.py

249 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""合成择时消费与退出恢复:隔离SQLite,不联网、不伪造真机验收。"""
import unit_test_guard
import copy
import datetime as dt
import unittest
from unittest.mock import patch
import test_risk_exit as base
import test_signal_recovery as recovery
from app.core import timing_fusion_contract as contract, risk_exit as rules
from app.services import timing_fusion, timing_state, risk_exit, consensus_service, signal_service
from app.repo import rotation_repo
def fused(action='SELL', at=base.NOW, n=1):
sign=1 if action=='BUY' else -1 if action=='SELL' else 0
end=at+dt.timedelta(seconds=100)
groups={}
for group in contract.GROUPS:
evidence=[] if group=='qrs' else [{'ts_code':base.CODE,'group':group,'direction':sign,
'at':at.isoformat(),'expires_at':(at+dt.timedelta(minutes=45)).isoformat(),
'identity':rules.digest([group,n]),'source':group}]
groups[group]={'weight':1/3,'direction':sign if evidence else 0,
'state':'VALID' if evidence else 'UNKNOWN','evidence':evidence}
return {'version':contract.VERSION,'source':'timing_fusion','ts_code':base.CODE,'key':rules.digest([action,n]),
'action':action,'score':sign*2/3,'coverage':2,'groups':groups,'at':at.isoformat(),
'verified_at':at.isoformat(),'expires_at':end.isoformat(),'reason':'隔离测试证据'}
def daily_qrs_and_v3f(at=base.NOW, n=1):
value=fused(at=at,n=n)
qrs=copy.deepcopy(value['groups']['main_fund'])
start=at.replace(hour=9,minute=30,second=0,microsecond=0)
qrs['evidence'][0].update(group='qrs',source='daily_qrs_symmetric_down',
at=start.isoformat(),expires_at=at.replace(hour=15,minute=0,second=0,microsecond=0).isoformat(),
identity=rules.digest(['daily_qrs',str(at.date())]))
value['groups']['qrs']=qrs
value['groups']['main_fund']={'weight':1/3,'direction':0,'state':'UNKNOWN','evidence':[]}
return value
class ContractTests(unittest.TestCase):
def test_valid_not_a_model_probability(self):
value=fused();self.assertNotIn('confidence',value);self.assertIsNotNone(contract.valid(value,base.NOW))
def test_invalid_boundaries(self):
v=fused()
for changes in [{'ts_code':'920000.BJ'},{'source':'intraday'},{'version':'old'},
{'verified_at':(base.NOW+dt.timedelta(seconds=1)).isoformat()},
{'expires_at':base.NOW.isoformat()},{'key':'x'},{'score':-.3}]:
self.assertIsNone(contract.valid({**v,**changes},base.NOW))
self.assertIsNone(contract.valid(v,base.NOW,since=''))
self.assertIsNone(contract.valid(v,base.NOW+dt.timedelta(seconds=101)))
def test_transport_refresh_not_new_signal(self):
a=fused();b={**a,'verified_at':(base.NOW+dt.timedelta(seconds=30)).isoformat()}
self.assertTrue(contract.duplicate([a],b))
def test_only_one_new_group_cannot_confirm_second_exit(self):
a=fused();b=fused(at=base.NOW+dt.timedelta(minutes=5),n=2)
b['groups']['main_fund']=copy.deepcopy(a['groups']['main_fund'])
self.assertTrue(contract.duplicate([a],b))
def test_two_new_groups_confirm_second_exit(self):
self.assertFalse(contract.duplicate([fused()],fused(at=base.NOW+dt.timedelta(minutes=5),n=2)))
def test_daily_qrs_does_not_refresh_when_only_intraday_group_changes(self):
a=daily_qrs_and_v3f();later=base.NOW+dt.timedelta(minutes=5)
b=daily_qrs_and_v3f(later,2)
self.assertIsNotNone(contract.valid(b,later))
self.assertTrue(contract.duplicate([a],b))
def test_two_new_intraday_groups_can_confirm_despite_same_daily_qrs(self):
a=daily_qrs_and_v3f();later=base.NOW+dt.timedelta(minutes=5)
b=fused(at=later,n=2);b['groups']['qrs']=copy.deepcopy(a['groups']['qrs']);b['score']=-1
self.assertIsNotNone(contract.valid(b,later))
self.assertFalse(contract.duplicate([a],b))
def test_next_day_new_qrs_and_intraday_group_can_confirm(self):
a=daily_qrs_and_v3f();later=base.NOW+dt.timedelta(days=1)
b=daily_qrs_and_v3f(later,2)
self.assertIsNotNone(contract.valid(b,later))
self.assertFalse(contract.duplicate([a],b))
def test_group_with_retained_old_subsource_is_not_independent_refresh(self):
a=fused();later=base.NOW+dt.timedelta(minutes=5);b=fused(at=later,n=2)
b['groups']['main_fund']['evidence'].extend(copy.deepcopy(a['groups']['main_fund']['evidence']))
self.assertTrue(contract.duplicate([a],b))
class ServiceTests(recovery.DirectionTests):
# 只运行本类专用测试,沿用已有SQLite双策略和持仓桩。
def setup_fusion(self):
now=self.setup_direction()
self.params.update(PMS_TIMING_FUSION_ENABLED=True,PMS_TIMING_FUSION_START_AT=base.START.isoformat())
return now
def save(self,event):
with rotation_repo.locked(timing_state.key(base.CODE),timing_state.KIND,{}) as current:
current.clear();current.update(event)
def test_fusion_first_stop_replay_then_second_exit(self):
now=self.setup_fusion();a=fused(at=now);self.save(a)
self.assertEqual(risk_exit.on_signal(a,now=now)['count'],1)
self.assertEqual(risk_exit.on_signal(a,now=now)['count'],1)
b=fused(at=now+dt.timedelta(minutes=5),n=2);self.save(b)
self.assertEqual(risk_exit.on_signal(b,now=now+dt.timedelta(minutes=5))['count'],2)
self.assertEqual(len(self.instructions()),1)
def test_daily_qrs_waits_then_next_day_evidence_creates_one_exit(self):
now=self.setup_fusion();a=daily_qrs_and_v3f(now);self.save(a)
self.assertEqual(risk_exit.on_signal(a,now=now)['count'],1)
later=now+dt.timedelta(minutes=5);b=daily_qrs_and_v3f(later,2);self.save(b)
self.assertEqual(risk_exit.on_signal(b,now=later)['count'],1)
self.assertEqual(self.instructions(),[])
tomorrow=now+dt.timedelta(days=1);c=daily_qrs_and_v3f(tomorrow,3);self.save(c)
self.assertEqual(risk_exit.on_signal(c,now=tomorrow)['count'],2)
self.assertEqual(len(self.instructions()),1)
def test_fusion_new_buy_recovers_without_confidence_fabrication(self):
now=self.setup_fusion();a=fused(at=now);self.save(a);risk_exit.on_signal(a,now=now)
later=now+dt.timedelta(minutes=5);b=fused('BUY',later,2);self.save(b)
self.assertTrue(risk_exit.recover_on_buy(base.CODE,b,now=later)['recovered'])
self.assertEqual(self.state()['phase'],'WATCH');self.assertEqual(self.instructions(),[])
def test_fusion_expired_cannot_revert_to_nightly_buy(self):
now=self.setup_fusion();a=fused(at=now);self.save(a)
blocks=consensus_service.assemble({'ts_code':base.CODE,'company_review':base.review()},
nightly={'verdict':'BUY'},tech_states=consensus_service.state_map(),now=now+dt.timedelta(minutes=3))
self.assertEqual(blocks['timing']['stance'],'无读数');self.assertNotEqual(blocks['consensus']['route'],'放行')
def test_fusion_old_model_broadcast_never_double_counts(self):
now=self.setup_fusion();a=fused(at=now);self.save(a);risk_exit.on_signal(a,now=now)
out={'ignored':0}
signal_service._handle(base.signal(2),{}, {},{},20261105,False,out)
self.assertEqual(self.state()['count'],1);self.assertEqual(out['ignored'],1)
def test_old_warning_pause_recovers_but_manual_pause_does_not(self):
from app.services import strategy_service
now=self.setup_fusion()
risk_exit.observe_review(base.CODE,base.review(),now=now)
strategy_service.pause_buy(base.CODE,source='intraday',reason='历史预警')
b=fused('BUY',now+dt.timedelta(minutes=5),2);self.save(b)
self.assertTrue(risk_exit.recover_on_buy(base.CODE,b,now=now+dt.timedelta(minutes=5))['recovered'])
def test_polling_lease_does_not_enqueue_new_model_task(self):
from app.services import judge_async
a=fused('BUY');b={**a,'expires_at':(base.NOW+dt.timedelta(seconds=110)).isoformat()}
x={'hard_numbers':{'timing':{'event':a}}};y={'hard_numbers':{'timing':{'event':b}}}
payload={'action':'OPEN','timing_fusion_scope':'pms-sim-155','timing_fusion':{'key':a['key']}}
self.assertEqual(judge_async.identity(x,payload),judge_async.identity(y,payload))
def test_refresh_is_idempotent_and_preserves_state_on_replay(self):
from types import SimpleNamespace
now=self.setup_fusion();a=fused(at=now)
response=SimpleNamespace(raise_for_status=lambda:None,json=lambda:{'version':contract.VERSION,'enabled':True,'states':[a]})
with patch('requests.get',return_value=response):
self.assertEqual(timing_fusion.refresh(now=now)['accepted'],1)
self.assertEqual(timing_fusion.refresh(now=now)['accepted'],1)
self.assertEqual(self.state()['count'],1)
self.assertEqual(timing_state.latest(base.CODE,now)['key'],a['key'])
def test_broad_missing_states_do_not_write_unrelated_ledger(self):
from types import SimpleNamespace
now=self.setup_fusion();a=fused('WAIT',at=now)
response=SimpleNamespace(raise_for_status=lambda:None,json=lambda:{'version':contract.VERSION,'enabled':True,'states':[a]})
with patch('requests.get',return_value=response):
self.assertEqual(timing_fusion.refresh(now=now)['accepted'],0)
self.save(fused('BUY',at=now))
self.assertEqual(timing_fusion.refresh(now=now)['accepted'],1)
self.assertEqual(timing_state.latest(base.CODE,now)['action'],'WAIT')
def test_refresh_verifies_at_receipt_and_preserves_lease(self):
import json
import requests
from app.services import exec_advisor
sent = self.setup_fusion()
received = sent + dt.timedelta(milliseconds=20)
current = [sent]
event = fused(at=sent)
event['verified_at'] = (sent + dt.timedelta(milliseconds=5)).isoformat()
def get(url, timeout):
self.assertTrue(url.endswith('/api/intraday/timing_fusion'))
current[0] = received
response = requests.Response()
response.status_code = 200
response._content = json.dumps({'version': contract.VERSION, 'enabled': True,
'states': [event]}).encode()
return response
with patch.object(timing_fusion, 'datetime') as clock, patch.object(exec_advisor, 'base_url', return_value='http://offline.invalid'), patch.object(requests, 'get', side_effect=get):
clock.now.side_effect = lambda: current[0]
first = timing_fusion.refresh()
self.assertEqual((first['accepted'], first['invalid'], self.state()['phase']), (1, 0, 'STOP_BUY'))
event['verified_at'] = (received + dt.timedelta(milliseconds=5)).isoformat()
self.assertEqual(timing_fusion.refresh()['status'], 'FAILED')
event['verified_at'] = sent.isoformat()
event['expires_at'] = received.isoformat()
self.assertEqual(timing_fusion.refresh()['status'], 'FAILED')
self.assertEqual(self.state()['count'], 1)
def test_actual_digest_reports_partial_batch_wait_and_failure(self):
import requests
from app import scheduler
from app.services import exec_advisor
from types import SimpleNamespace
now = self.setup_fusion()
wait = fused('WAIT', at=now)
response = {'version': contract.VERSION, 'enabled': True, 'states': [wait]}
with patch.object(signal_service.portfolio, 'positions_view', return_value={}), \
patch.object(signal_service, 'streams', return_value=[]), patch.object(signal_service, '_load_seen', return_value={}), \
patch.object(exec_advisor, 'base_url', return_value='http://offline.invalid'), \
patch.object(timing_fusion, 'datetime') as clock, patch.object(requests, 'get', return_value=SimpleNamespace(raise_for_status=lambda:None, json=lambda:response)):
clock.now.return_value = now
def digest():
return signal_service.consume(dry_run=True)
clean = digest()
self.assertTrue(clean['ok'])
self.assertEqual(clean['timing_fusion']['status'], 'NO_DIRECTION')
self.assertIn('NO_DIRECTION', scheduler._brief(clean))
response['states'] = []
self.assertEqual(digest()['timing_fusion']['status'], 'NO_EVIDENCE')
response.update(states=[fused(at=now), None], errors=['主力资金来源异常'])
partial = digest()
self.assertFalse(partial['ok'])
self.assertEqual(partial['timing_fusion']['accepted'], 1)
self.assertEqual(partial['timing_fusion']['status'], 'DEGRADED')
response['states'] = [None]
failure = digest()
self.assertFalse(failure['ok'])
self.assertIn('FAILED', scheduler._brief(failure))
def test_previously_known_wait_after_one_thousand_other_rows_is_saved(self):
from types import SimpleNamespace
now = self.setup_fusion()
self.save(fused(at=now))
ids = [{'doc_id':'timing-direction:' + str(600100 + i) + '.SH', 'kind':timing_state.KIND,
'payload_json':'{}', 'revision':1, 'updated_at':'2099-01-01'} for i in range(1001)]
from sqlalchemy import text
with self.engine.begin() as conn:
conn.execute(text('INSERT INTO pms_rotation_document VALUES (:doc_id,:kind,:payload_json,:revision,:updated_at)'), ids)
payload = {'version': contract.VERSION, 'enabled': True, 'states':[fused('WAIT',at=now,n=2)]}
with patch('requests.get', return_value=SimpleNamespace(raise_for_status=lambda:None, json=lambda:payload)):
self.assertEqual(timing_fusion.refresh(now=now)['accepted'], 1)
self.assertEqual(timing_state.latest(base.CODE,now)['action'], 'WAIT')
with patch.object(rotation_repo, 'document_ids', return_value=set(range(6001))):
with self.assertRaisesRegex(ValueError, '超过完整读取上限'):
timing_fusion.refresh(now=now)
def test_fusion_manual_halt_not_recovered(self):
now=self.setup_fusion();a=fused(at=now);self.save(a);risk_exit.on_signal(a,now=now)
self.params['PMS_GLOBAL_BUY_HALT']=True
later=now+dt.timedelta(minutes=5);b=fused('BUY',later,2);self.save(b)
self.assertFalse(risk_exit.recover_on_buy(base.CODE,b,now=later)['recovered'])
# 基类既有用例由原批次运行,避免本批重复计数。
for name in list(recovery.DirectionTests.__dict__):
if name.startswith('test_') and name not in ServiceTests.__dict__:
setattr(ServiceTests,name,None)
if __name__=='__main__': unittest.main()