2026-11-13 09:24:02 +08:00
|
|
|
"""宽基查询离线契约、缓存隔离及页面只读接入。数据均为合成测试数据。"""
|
|
|
|
|
import unit_test_guard
|
|
|
|
|
import contextlib
|
|
|
|
|
import copy
|
|
|
|
|
from datetime import datetime, timedelta
|
|
|
|
|
import json
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
import sys
|
|
|
|
|
from unittest import TestCase, main
|
|
|
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
|
|
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
|
|
from app.core import etf_query_view as view
|
|
|
|
|
from app.services import etf_query as svc, param_store
|
|
|
|
|
|
|
|
|
|
DAY = '2026-11-12'
|
|
|
|
|
NOW = datetime.fromisoformat(DAY + 'T10:02:00+08:00')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def fixture(day=DAY, revision=1):
|
|
|
|
|
rows = []
|
|
|
|
|
for hm, amount, direction, balance in [('09:45', 1e8, 'BUY', .3), ('10:00', 2e8, 'SELL', -.4)]:
|
|
|
|
|
end = datetime.fromisoformat(day + 'T' + hm + ':00+08:00')
|
|
|
|
|
rows.append(dict(subject_type='MARKET', subject_id='BROAD_ETF', interval_minutes=15,
|
|
|
|
|
window_start=(end-timedelta(minutes=15)).isoformat(), window_end=end.isoformat(),
|
|
|
|
|
member_count=1, amount_member_count=1, direction_member_count=1,
|
|
|
|
|
amount_coverage=1., direction_coverage=1., amount_status='COMPLETE', direction_status='OK',
|
|
|
|
|
direction=direction, direction_balance=balance, turnover_yuan=amount,
|
|
|
|
|
cumulative_turnover_yuan=1e8 if hm=='09:45' else 3e8,
|
|
|
|
|
source_windows=[{'window_end':end.isoformat(),'sources':[{'source':'TEST_FACT'}]}],
|
|
|
|
|
top_turnover_members=[{'ts_code':'510300.SH'}]))
|
|
|
|
|
return dict(contract_version=view.CONTRACT, trade_date=day, view=view.VIEW, interval_minutes=15,
|
|
|
|
|
timezone='Asia/Shanghai', amount_unit='CNY', purpose='MARKET_OBSERVATION',
|
|
|
|
|
flow_basis='PRICE_VOLUME_PROXY_NOT_NET_SUBSCRIPTION', proxy_method='minute-price-change-signed-turnover-v1',
|
|
|
|
|
intraday_net_subscription_status='UNAVAILABLE_DAILY_ONLY', intraday_net_subscription_yuan=None,
|
|
|
|
|
trade_instruction=False, live_signal_eligibility=False, historical_use_allowed=True,
|
|
|
|
|
projection_revision=revision, projected_at=day+'T10:01:00+08:00',
|
|
|
|
|
data_version=str(revision)*64, cohort_sha256='b'*64,
|
|
|
|
|
groups=[dict(subject_type='MARKET',subject_id='BROAD_ETF',members=['510300.SH'])], rows=rows)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def catalog(day=DAY):
|
|
|
|
|
return dict(contract_version=view.CONTRACT, intervals_minutes=[15,30], views=['latest_facts','as_published'],
|
|
|
|
|
timezone='Asia/Shanghai',dates=[{'trade_date':day,'status':'AVAILABLE'}])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MemoryStore:
|
|
|
|
|
def __init__(self): self.docs = {}; self.fail = False
|
|
|
|
|
def get(self, key): return copy.deepcopy(self.docs.get(key)), 1
|
|
|
|
|
def put_once(self, key, kind, value):
|
|
|
|
|
if self.fail: raise RuntimeError('store unavailable')
|
|
|
|
|
if key in self.docs: assert self.docs[key] == value
|
|
|
|
|
self.docs[key] = copy.deepcopy(value)
|
|
|
|
|
@contextlib.contextmanager
|
|
|
|
|
def locked(self, key, kind, initial):
|
|
|
|
|
value = copy.deepcopy(self.docs.get(key, initial))
|
|
|
|
|
yield value
|
|
|
|
|
self.docs[key] = value
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ViewTests(TestCase):
|
|
|
|
|
def test_real_weights_kept_and_cumulative_not_summed(self):
|
|
|
|
|
doc=fixture();view.validate(doc,DAY,NOW);out=view.presentation(doc,NOW)
|
|
|
|
|
self.assertEqual(out['summary']['cumulative_amount'],3e8)
|
|
|
|
|
self.assertEqual([r['value'] for r in out['intraday_series'][:2]],[.3,-.4])
|
|
|
|
|
self.assertFalse(out['trade_instruction']);self.assertFalse(out['live_signal_eligibility'])
|
|
|
|
|
def test_fixed_slots_and_lunch_gap(self):
|
|
|
|
|
rows=view.presentation(fixture(),NOW)['intraday_series']
|
|
|
|
|
self.assertEqual(len(rows),16);self.assertEqual((rows[7]['end'],rows[8]['start']),('11:30','13:00'))
|
|
|
|
|
self.assertEqual(rows[2]['state'],'pending')
|
|
|
|
|
def test_missing_direction_preserves_complete_amount(self):
|
|
|
|
|
doc=fixture();doc['rows'][1].update(direction_status='UNAVAILABLE',direction_balance=None)
|
|
|
|
|
out=view.presentation(doc,NOW);self.assertEqual(out['summary']['cumulative_amount'],3e8)
|
|
|
|
|
self.assertIsNone(out['intraday_series'][1]['value'])
|
|
|
|
|
def test_true_zero_and_missing_differ(self):
|
|
|
|
|
doc=fixture();doc['rows'][0].update(direction_balance=0,direction='MIXED')
|
|
|
|
|
doc['rows'][1].update(direction_coverage=.5)
|
|
|
|
|
rows=view.presentation(doc,NOW)['intraday_series']
|
|
|
|
|
self.assertEqual((rows[0]['state'],rows[0]['value']),('ok',0))
|
|
|
|
|
self.assertEqual((rows[1]['state'],rows[1]['value']),('missing',None))
|
|
|
|
|
def test_incomplete_amount_never_shown_as_complete_cumulative(self):
|
|
|
|
|
doc=fixture();doc['rows'][0]['amount_status']='INCOMPLETE'
|
|
|
|
|
self.assertIsNone(view.presentation(doc,NOW)['summary']['cumulative_amount'])
|
|
|
|
|
def test_nonfinite_bool_and_out_of_range_not_neutral(self):
|
|
|
|
|
for bad in (True,float('nan'),float('inf'),1.01,'0'):
|
|
|
|
|
doc=fixture();doc['rows'][0]['direction_balance']=bad
|
|
|
|
|
self.assertIsNone(view.presentation(doc,NOW)['intraday_series'][0]['value'])
|
|
|
|
|
def test_contract_purpose_and_scope_rejected(self):
|
|
|
|
|
for key,bad in [('view','as_published'),('interval_minutes',30),('trade_date','2026-11-11'),
|
|
|
|
|
('trade_instruction',True),('live_signal_eligibility',True),('amount_unit','万元')]:
|
|
|
|
|
doc=fixture();doc[key]=bad
|
|
|
|
|
with self.assertRaises(ValueError):view.validate(doc,DAY,NOW)
|
|
|
|
|
def test_duplicate_window_and_future_facts_rejected(self):
|
|
|
|
|
doc=fixture();doc['rows'].append(copy.deepcopy(doc['rows'][0]))
|
|
|
|
|
with self.assertRaises(ValueError):view.validate(doc,DAY,NOW)
|
|
|
|
|
with self.assertRaises(ValueError):view.validate(fixture(),DAY,NOW-timedelta(minutes=20))
|
|
|
|
|
def test_only_sh_sz_group_accepted(self):
|
|
|
|
|
for code in ('920001.BJ','bad','000300.CSI'):
|
|
|
|
|
doc=fixture();doc['groups'][0]['members']=[code]
|
|
|
|
|
with self.assertRaises(ValueError):view.validate(doc,DAY,NOW)
|
|
|
|
|
def test_catalog_selects_actual_day_not_future_or_available_fallback(self):
|
|
|
|
|
doc=catalog();doc['dates'] += [{'trade_date':'2026-11-11'},{'trade_date':'2026-11-13'}]
|
|
|
|
|
self.assertEqual(view.latest_day(doc,NOW),DAY)
|
|
|
|
|
doc['dates'][0]['status']='UNAVAILABLE';self.assertEqual(view.latest_day(doc,NOW),DAY)
|
|
|
|
|
def test_expired_signal_does_not_hide_history(self):
|
|
|
|
|
out=view.presentation(fixture(),NOW+timedelta(days=1))
|
|
|
|
|
self.assertEqual(out['summary']['trade_date'],DAY);self.assertEqual(out['intraday_series'][0]['value'],.3)
|
|
|
|
|
self.assertEqual(out['intraday_series'][2]['state'],'missing')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ConsumerTests(TestCase):
|
|
|
|
|
def setUp(self):
|
|
|
|
|
self.stack=contextlib.ExitStack();self.addCleanup(self.stack.close);self.store=MemoryStore()
|
|
|
|
|
self.stack.enter_context(patch.object(svc,'store',self.store))
|
|
|
|
|
self.stack.enter_context(patch.object(param_store,'get_bool',return_value=True))
|
|
|
|
|
self.stack.enter_context(patch.object(param_store,'get',return_value='http://example.test'))
|
|
|
|
|
self.stack.enter_context(patch.object(svc.settings,'PMS_ETF_QUERY_API_KEY','synthetic-secret'))
|
|
|
|
|
self.at=NOW;self.doc=fixture();self.cat=catalog();self.code=200;self.calls=[]
|
|
|
|
|
def request(self,base,path,key,etag=None):
|
|
|
|
|
self.calls.append((path,etag))
|
|
|
|
|
if path.endswith('/catalog'):return 200,self.cat,None
|
|
|
|
|
return self.code,copy.deepcopy(self.doc) if self.code==200 else None,'"test"'
|
|
|
|
|
def runonce(self):return svc.consume_once(requester=self.request,clock=lambda:self.at)
|
|
|
|
|
def state(self):return self.store.docs[svc.STATE_KEY]
|
|
|
|
|
def test_200_archives_before_cache_and_304_retains(self):
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'ok');first=copy.deepcopy(self.state()['document'])
|
|
|
|
|
self.assertEqual(len(self.store.docs),2);self.at+=timedelta(seconds=60);self.code=304
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'ok');self.assertEqual(self.calls[-1][1],'"test"')
|
|
|
|
|
self.assertEqual(self.state()['document'],first);self.assertEqual(len(self.store.docs),2)
|
|
|
|
|
def test_poll_minute_budget(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(seconds=59);self.assertEqual(self.runonce()['status'],'idle')
|
|
|
|
|
self.assertEqual(len(self.calls),2)
|
|
|
|
|
def test_errors_preserve_document_and_hide_sensitive_details(self):
|
|
|
|
|
self.runonce();old=copy.deepcopy(self.state()['document']);self.at+=timedelta(seconds=60)
|
|
|
|
|
for code in ('HTTP_401','HTTP_404','HTTP_503','NETWORK'):
|
|
|
|
|
def failing(*a):raise svc.QueryUnavailable(code)
|
|
|
|
|
svc.consume_once(requester=failing,clock=lambda:self.at)
|
|
|
|
|
self.assertEqual(self.state()['document'],old);self.assertEqual(self.state()['error'],code)
|
|
|
|
|
self.at+=timedelta(seconds=60)
|
|
|
|
|
def test_bad_contract_does_not_replace_cache(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(seconds=60);self.doc['amount_unit']='万元'
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'unavailable');self.assertEqual(self.state()['document']['amount_unit'],'CNY')
|
|
|
|
|
def test_old_revision_and_same_revision_mutation_rejected(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(seconds=60);self.doc=fixture(revision=0)
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'unavailable')
|
|
|
|
|
self.at+=timedelta(seconds=60);self.doc=fixture();self.doc['rows'][0]['turnover_yuan']=9e8
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'unavailable')
|
|
|
|
|
def test_new_revision_archived_without_erasing_old(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(seconds=60);self.doc=fixture(revision=2)
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'ok');self.assertEqual(len(self.store.docs),3)
|
|
|
|
|
def test_day_change_never_reuses_etag(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(days=1);self.cat=catalog('2026-11-13');self.doc=fixture('2026-11-13')
|
|
|
|
|
self.runonce();self.assertIsNone(self.calls[-1][1]);self.assertEqual(self.state()['document']['trade_date'],'2026-11-13')
|
|
|
|
|
def test_url_change_never_reuses_etag(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(seconds=60)
|
|
|
|
|
with patch.object(param_store,'get',return_value='http://other.test'):self.runonce()
|
|
|
|
|
self.assertIsNone(self.calls[-1][1])
|
|
|
|
|
def test_304_without_cache_rejected(self):
|
|
|
|
|
self.code=304;self.assertEqual(self.runonce()['status'],'unavailable');self.assertNotIn('document',self.state())
|
|
|
|
|
def test_archive_failure_does_not_advance_cache(self):
|
|
|
|
|
self.store.fail=True
|
|
|
|
|
with self.assertRaises(RuntimeError):self.runonce()
|
|
|
|
|
self.assertNotIn(svc.STATE_KEY,self.store.docs)
|
|
|
|
|
def test_read_endpoint_never_fetches_or_reveals_secret(self):
|
|
|
|
|
self.runonce()
|
|
|
|
|
with patch.object(svc,'fetch',side_effect=AssertionError('no HTTP in page')):out=svc.status()
|
|
|
|
|
self.assertNotIn('synthetic-secret',json.dumps(out));self.assertNotIn('etag',out)
|
|
|
|
|
self.assertIn('PMS_ETF_QUERY_API_KEY',param_store.SECRET_KEYS)
|
|
|
|
|
self.assertNotIn('PMS_ETF_QUERY_API_KEY',param_store._editable_keys())
|
|
|
|
|
def test_stopped_poll_marks_unavailable_but_keeps_dated_history(self):
|
|
|
|
|
self.runonce()
|
|
|
|
|
with patch.object(svc,'datetime') as clock:
|
|
|
|
|
clock.now.return_value=NOW+timedelta(seconds=181)
|
|
|
|
|
result=svc.status()
|
|
|
|
|
self.assertEqual(result['status'],'unavailable')
|
|
|
|
|
self.assertEqual(result['summary']['trade_date'],DAY)
|
|
|
|
|
self.assertEqual(result['intraday_series'][0]['value'],.3)
|
2026-11-13 09:52:55 +08:00
|
|
|
def test_previous_day_hidden_even_when_catalog_poll_succeeds_today(self):
|
|
|
|
|
self.runonce();original=copy.deepcopy(self.state()['document'])
|
|
|
|
|
tomorrow=NOW+timedelta(days=1);self.state()['last_success_at']=tomorrow.isoformat()
|
|
|
|
|
with patch.object(svc,'datetime') as clock:
|
|
|
|
|
clock.now.return_value=tomorrow;result=svc.status()
|
|
|
|
|
self.assertEqual(result['status'],'waiting')
|
|
|
|
|
self.assertEqual(result['summary']['trade_date'],'2026-11-13')
|
|
|
|
|
self.assertIsNone(result['summary']['cumulative_amount']);self.assertEqual(result['intraday_series'],[])
|
|
|
|
|
self.assertEqual(self.state()['document'],original)
|
|
|
|
|
def test_failure_never_restores_previous_day(self):
|
|
|
|
|
self.runonce();self.state()['error']='NETWORK'
|
|
|
|
|
with patch.object(svc,'datetime') as clock:
|
|
|
|
|
clock.now.return_value=NOW+timedelta(days=1);result=svc.status()
|
|
|
|
|
self.assertEqual(result['status'],'unavailable');self.assertEqual(result['intraday_series'],[])
|
|
|
|
|
self.assertIsNone(result['summary']['window_end'])
|
|
|
|
|
def test_beijing_midnight_changes_visible_day(self):
|
|
|
|
|
self.runonce()
|
|
|
|
|
with patch.object(svc,'datetime') as clock:
|
|
|
|
|
clock.now.return_value=datetime.fromisoformat('2026-11-12T15:59:59+00:00')
|
|
|
|
|
self.assertEqual(len(svc.status()['intraday_series']),16)
|
|
|
|
|
clock.now.return_value=datetime.fromisoformat('2026-11-12T16:00:00+00:00')
|
|
|
|
|
self.assertEqual(svc.status()['intraday_series'],[])
|
|
|
|
|
def test_first_current_day_response_appears_without_replaying_history(self):
|
|
|
|
|
self.runonce();self.at+=timedelta(days=1);self.cat=catalog('2026-11-13');self.doc=fixture('2026-11-13')
|
|
|
|
|
self.runonce()
|
|
|
|
|
with patch.object(svc,'datetime') as clock:
|
|
|
|
|
clock.now.return_value=self.at;result=svc.status()
|
|
|
|
|
self.assertEqual(result['status'],'ok');self.assertEqual(result['summary']['trade_date'],'2026-11-13')
|
|
|
|
|
self.assertEqual(result['summary']['cumulative_amount'],3e8)
|
|
|
|
|
self.assertEqual(len(self.store.docs),3)
|
2026-11-13 09:24:02 +08:00
|
|
|
def test_disabled_no_network_or_storage(self):
|
|
|
|
|
with patch.object(param_store,'get_bool',return_value=False):
|
|
|
|
|
self.assertEqual(self.runonce()['status'],'disabled');self.assertFalse(svc.status()['enabled'])
|
|
|
|
|
self.assertFalse(self.calls);self.assertFalse(self.store.docs)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class HttpTests(TestCase):
|
|
|
|
|
def session(self,status,body):
|
|
|
|
|
response=MagicMock();response.status_code=status;response.headers={'ETag':'"a"'}
|
|
|
|
|
response.iter_content.return_value=[body];response.__enter__.return_value=response
|
|
|
|
|
session=MagicMock();session.get.return_value=response;session.__enter__.return_value=session
|
|
|
|
|
return session
|
|
|
|
|
def test_timeout_redirect_and_conditional_header(self):
|
|
|
|
|
session=self.session(200,b'{"test":1}')
|
|
|
|
|
with patch.object(svc.requests,'Session',return_value=session):
|
|
|
|
|
self.assertEqual(svc.fetch('http://example.test','/path','synthetic-secret','"before"')[1],{'test':1})
|
|
|
|
|
self.assertFalse(session.trust_env);kw=session.get.call_args.kwargs
|
|
|
|
|
self.assertEqual(kw['timeout'],(2,5));self.assertFalse(kw['allow_redirects'])
|
|
|
|
|
self.assertEqual(kw['headers']['If-None-Match'],'"before"')
|
|
|
|
|
def test_unauthorized_redirect_and_size_limit(self):
|
|
|
|
|
for code,body in [(401,b'secret'),(302,b''),(200,b' '* (svc.MAX_BYTES+1))]:
|
|
|
|
|
with patch.object(svc.requests,'Session',return_value=self.session(code,body)):
|
|
|
|
|
with self.assertRaises(svc.QueryUnavailable) as cm:svc.fetch('http://example.test','/path','synthetic-secret')
|
|
|
|
|
self.assertNotIn('secret',str(cm.exception))
|
|
|
|
|
def test_url_credentials_and_missing_key_rejected(self):
|
|
|
|
|
with self.assertRaises(svc.QueryUnavailable):svc.fetch('http://user:password@example.test','/path','key')
|
|
|
|
|
with self.assertRaises(svc.QueryUnavailable):svc.fetch('http://example.test','/path','')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':main()
|