128 lines
9.4 KiB
Python
128 lines
9.4 KiB
Python
"""每日资金接入与完整信号覆盖;合成事实和内存存储,不读取线上行情。"""
|
|
import unit_test_guard
|
|
import contextlib
|
|
import copy
|
|
import hashlib
|
|
import json
|
|
import sys
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
from unittest import TestCase, main
|
|
from unittest.mock import patch
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
from test_etf_observation import MemoryStore, RedisFake
|
|
from app.services import broad_funds as svc, upstream_signals as up, param_store
|
|
from app.core.etf_contract.daily_flow import CONTRACT, ETF_BASIS, INDUSTRY_BASIS, THRESHOLD, canonical
|
|
|
|
AT = datetime.fromisoformat('2026-11-06T10:00:00+08:00')
|
|
DAY = '2026-11-05'
|
|
|
|
|
|
def facts(rev=0, day=DAY, amount=100., sectors=True):
|
|
subject = {'subject_id': 'BROAD_ETF', 'subject_type': 'MARKET', 'latest': {
|
|
'trade_date': day, 'net_flow_yuan': amount, 'member_count': 1, 'observed_member_count': int(amount is not None)},
|
|
'daily_series': [{'trade_date': day, 'net_flow_yuan': amount}], 'periods': {}, 'reference': {'percentile': None}}
|
|
industry = {'subject_id': 'test-industry', 'name': '测试行业', 'latest': {'net_flow_yuan': 1.}}
|
|
return dict(schema_version=1, contract_version=CONTRACT, threshold_version=THRESHOLD,
|
|
model_status='uncalibrated', calibration_status='PROVISIONAL', purpose='MARKET_OBSERVATION',
|
|
publication_mode='observation', trade_instruction=False, accounting_bases_combined=False,
|
|
trade_date=day, valid_for_trade_date=day, published_at=(AT-timedelta(minutes=1)).isoformat(),
|
|
revision=rev, supersedes_revision=rev-1 if rev else None,
|
|
component_status={'etf': 'AVAILABLE_ESTIMATE' if amount is not None else 'AWAITING_COMPLETE_SHARES_NAV',
|
|
'industry': 'AVAILABLE_REPORTED' if sectors else 'AWAITING_SOURCE'},
|
|
etf={'flow_basis': ETF_BASIS, 'cohort': {'510300.SH': '000300.SH'}, 'market': subject,
|
|
'etfs': [], 'indexes': [dict(subject, subject_id='932000.CSI', subject_type='INDEX')]},
|
|
industry={'flow_basis': INDUSTRY_BASIS, 'total': None, 'sectors': [industry] if sectors else []})
|
|
|
|
|
|
class DailyBus(RedisFake):
|
|
def exists(self,key): return key.endswith(DAY[:7])
|
|
|
|
|
|
class DailyTests(TestCase):
|
|
def setUp(self):
|
|
self.stack=contextlib.ExitStack();self.addCleanup(self.stack.close)
|
|
self.store=MemoryStore();self.snap,self.bus=RedisFake(),DailyBus(self.store)
|
|
self.stack.enter_context(patch.object(svc,'store',self.store))
|
|
self.stack.enter_context(patch.object(param_store,'get_bool',return_value=True))
|
|
def load(self,rev=0,day=DAY,amount=100.,sectors=True,sid=None):
|
|
r=facts(rev,day,amount,sectors);raw=canonical(r);suffix=f'{day}:r{rev}'
|
|
mf={k:r[k] for k in ('schema_version','contract_version','trade_date','revision','published_at',
|
|
'purpose','model_status','calibration_status','trade_instruction')}
|
|
mf.update(namespace=svc.NS,status='READY',manifest_key=svc.NS+':manifest:'+suffix,
|
|
snapshot_key=svc.NS+':snapshot:'+suffix,snapshot_sha256=hashlib.sha256(raw.encode()).hexdigest(),
|
|
event_type='DAILY_UPSERT',window_epoch=1)
|
|
e=dict(mf,event_id=f'daily-flow:{day}:r{rev}',supersedes_revision=r['supersedes_revision'],component_status=r['component_status'])
|
|
self.bus.values[mf['manifest_key']]=canonical(mf);self.snap.values[mf['snapshot_key']]=raw
|
|
self.snap.values[svc.NS+':latest:'+day]=canonical(mf);self.snap.values[svc.NS+':latest']=canonical(mf)
|
|
self.bus.rows.append((sid or f'{rev+1}-0',{'data':canonical(e)}))
|
|
return r,mf,e
|
|
def runat(self,at=AT):return svc.consume_once(self.snap,self.bus,clock=lambda:at)
|
|
def view(self):return svc.status(clock=lambda:AT)
|
|
def test_valid_report_is_durable_before_ack_and_csi_index_kept(self):
|
|
self.load();self.assertEqual(self.runat()['status'],'ok');self.assertEqual(self.bus.acks,['1-0'])
|
|
v=self.view();self.assertEqual(v['report']['etf']['market']['latest']['net_flow_yuan'],100)
|
|
self.assertEqual(v['report']['etf']['indexes'][0]['name'],'中证2000');self.assertNotIn('etfs',v['report']['etf'])
|
|
self.assertFalse(v['trade_instruction'])
|
|
saved=self.store.docs[self.store.docs[svc.STATE]['days'][DAY]['key']]
|
|
self.assertEqual(hashlib.sha256(saved['snapshot_text'].encode()).hexdigest(), saved['manifest']['snapshot_sha256'])
|
|
def test_duplicate_is_acked_without_overwriting_first_receipt(self):
|
|
self.load();self.runat();first={k:v for k,v in self.store.docs.items() if ':event:' in k}
|
|
self.load();self.runat(AT+timedelta(seconds=3));self.assertEqual(first,{k:v for k,v in self.store.docs.items() if ':event:' in k})
|
|
def test_superseded_full_report_cannot_replace_new_pending_revision(self):
|
|
self.load();self.runat();self.load(rev=2,amount=None);self.runat();self.load(rev=1,sid='4-0');self.runat()
|
|
self.assertEqual(self.view()['report']['revision'],2);self.assertIsNone(self.view()['report']['etf']['market']['latest']['net_flow_yuan'])
|
|
def test_same_date_latest_pointer_blocks_old_event_before_first_ingestion(self):
|
|
self.load();self.load(rev=1,amount=None);self.runat();self.assertEqual(self.view()['report']['revision'],1)
|
|
audit=next(v for k,v in self.store.docs.items() if k.endswith(':1-0'));self.assertFalse(audit['applied']);self.assertTrue(audit['superseded'])
|
|
def test_partial_industry_does_not_hide_valid_etf(self):
|
|
self.load(sectors=False);self.runat();self.assertEqual(self.view()['report']['etf']['market']['latest']['net_flow_yuan'],100)
|
|
self.assertEqual(self.view()['report']['component_status']['industry'],'AWAITING_SOURCE')
|
|
def test_missing_etf_does_not_hide_industry_or_become_zero(self):
|
|
self.load(amount=None);self.runat();v=self.view()['report'];self.assertIsNone(v['etf']['market']['latest']['net_flow_yuan']);self.assertEqual(len(v['industry']['sectors']),1)
|
|
def test_database_failure_cannot_ack(self):
|
|
self.load();self.store.fail=True
|
|
with self.assertRaises(RuntimeError):self.runat()
|
|
self.assertFalse(self.bus.acks);self.store.fail=False;self.runat();self.assertEqual(self.bus.acks,['1-0'])
|
|
def test_corrupt_hash_pending_then_recovers(self):
|
|
r,m,e=self.load();raw=self.snap.values[m['snapshot_key']];self.snap.values[m['snapshot_key']]=raw+' '
|
|
self.assertEqual(self.runat()['status'],'unavailable');self.assertFalse(self.bus.acks)
|
|
self.snap.values[m['snapshot_key']]=raw;self.runat();self.assertEqual(self.bus.acks,['1-0'])
|
|
def test_bad_event_does_not_prevent_valid_later_event(self):
|
|
self.load();self.bus.rows[0][1]['data']='{}';self.load(rev=1)
|
|
self.assertEqual(self.runat()['status'],'unavailable');self.assertEqual(self.bus.acks,['2-0']);self.assertEqual(self.view()['report']['revision'],1)
|
|
def test_event_cannot_disagree_with_committed_version(self):
|
|
r,m,e=self.load();e['component_status']={'etf':'UNKNOWN'};self.bus.rows[0][1]['data']=canonical(e)
|
|
self.runat();self.assertFalse(self.bus.acks)
|
|
def test_latest_without_stream_can_recover(self):
|
|
self.load();self.bus.rows=[];self.runat();self.assertEqual(self.view()['report']['trade_date'],DAY)
|
|
def test_expected_date_and_future_and_bse_rejected(self):
|
|
r,m,e=self.load()
|
|
with self.assertRaises(ValueError):svc.ingest(self.snap,self.bus,m['manifest_key'],'2026-11-04',AT)
|
|
with self.assertRaises(ValueError):svc.validate_scope(dict(r,published_at=(AT+timedelta(seconds=1)).isoformat()),AT)
|
|
r['etf']['cohort']={'920001.BJ':'000300.SH'}
|
|
with self.assertRaises(ValueError):svc.validate_scope(r,AT)
|
|
def test_unavailable_keeps_explicit_old_date_and_facts(self):
|
|
self.load();self.runat();self.store.docs[svc.STATE]['error']='TimeoutError'
|
|
v=self.view();self.assertEqual(v['status'],'unavailable');self.assertEqual(v['report']['trade_date'],DAY)
|
|
def test_disabled_never_connects(self):
|
|
with patch.object(param_store,'get_bool',return_value=False),patch.object(svc.minute,'clients',side_effect=AssertionError('network')):
|
|
self.assertEqual(svc.consume_once()['status'],'disabled');self.assertFalse(self.view()['enabled'])
|
|
def test_official_vendor_bytes_pinned(self):
|
|
path=Path(svc.contract.__file__).parent;d=json.loads((path/'DAILY_PROVENANCE.json').read_text())
|
|
for name,digest in d['sha256'].items():self.assertEqual(hashlib.sha256((path/name).read_bytes()).hexdigest(),digest)
|
|
|
|
|
|
class CoverageTests(TestCase):
|
|
def setUp(self):up._focused_streams.clear()
|
|
def test_all_day_rows_and_categories_survive_old_limits(self):
|
|
rows=[(f'{int(AT.timestamp()*1000)+i}-0',{'ts_code':'600001.SH','source':'price_notice_up','level':'INFO','trigger_time':str(int(AT.timestamp()*1000))}) for i in range(501)]
|
|
rows.append(('1-0',{'ts_code':'920001.BJ'}))
|
|
with patch.object(up,'_focus_codes',return_value=set()),patch.object(param_store,'get_int',side_effect=lambda k,d=0:d),patch.object(up,'_scan_stream',return_value=(rows,False)):
|
|
self.assertEqual(len(up._read_alerts(None,DAY)['items']),501)
|
|
def test_cap_status_is_retained_in_coverage_cache(self):
|
|
with patch.object(up,'_focus_codes',return_value=set()),patch.object(param_store,'get_int',side_effect=lambda k,d=0:d),patch.object(up,'_scan_stream',return_value=([('1-0',{'ts_code':'600001.SH'})],True)):
|
|
up._entries(None,'test',1);self.assertTrue(next(iter(up._focused_streams.values()))['truncated'])
|
|
|
|
if __name__=='__main__':main()
|