238 lines
12 KiB
Python
238 lines
12 KiB
Python
|
|
"""限制价缓存及普通、微盘消费入口的隔离回归。无外部访问或状态写入。"""
|
||
|
|
import unit_test_guard # noqa: F401
|
||
|
|
import contextlib
|
||
|
|
import copy
|
||
|
|
from datetime import datetime, timedelta
|
||
|
|
from pathlib import Path
|
||
|
|
import sys
|
||
|
|
import unittest
|
||
|
|
from unittest.mock import patch
|
||
|
|
|
||
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||
|
|
|
||
|
|
import requests
|
||
|
|
from app.core import price_limits as core, execution_policy as policy
|
||
|
|
from app.services import price_limits as cache, market, rotation_service, param_store
|
||
|
|
|
||
|
|
DAY = '2026-11-03'
|
||
|
|
NOW = datetime(2026, 11, 3, 10, 0, tzinfo=policy.BEIJING)
|
||
|
|
A, B, BJ = '600000.SH', '000001.SZ', '920001.BJ'
|
||
|
|
|
||
|
|
|
||
|
|
def record(code=A, day=DAY, high='11.00'):
|
||
|
|
value = {'ts_code': code, 'trade_date': day, 'pre_close': '10.00',
|
||
|
|
'up_limit': high, 'down_limit': '9.00'}
|
||
|
|
return core.normalize_rows([value], day)['records'][code]
|
||
|
|
|
||
|
|
|
||
|
|
def entry(code=A, **changes):
|
||
|
|
return {'status': 'VALID', 'source': 'tushare.stk_limit',
|
||
|
|
'fetched_at': (NOW-timedelta(minutes=5)).isoformat(), 'record': record(code), **changes}
|
||
|
|
|
||
|
|
|
||
|
|
class PriceLimitCacheTests(unittest.TestCase):
|
||
|
|
def setUp(self):
|
||
|
|
self.stack = contextlib.ExitStack()
|
||
|
|
self.addCleanup(self.stack.close)
|
||
|
|
self.enabled = True
|
||
|
|
self.value = {'trade_date': DAY, 'entries': {A: entry(), B: entry(B)}}
|
||
|
|
self.stack.enter_context(patch.object(cache, 'local_now', return_value=NOW))
|
||
|
|
self.stack.enter_context(patch.object(param_store, 'get_bool', side_effect=lambda key, default=False:
|
||
|
|
self.enabled if key == 'PMS_LIMIT_CACHE_ENABLED' else default))
|
||
|
|
self.read = self.stack.enter_context(patch.object(cache.store, 'get',
|
||
|
|
side_effect=lambda key: (copy.deepcopy(self.value), 1)))
|
||
|
|
self.legacy = self.stack.enter_context(patch.object(cache.db, 'fetch_all', return_value=[]))
|
||
|
|
self.market_legacy = self.stack.enter_context(patch.object(market, 'fetch_all', return_value=[]))
|
||
|
|
self.bars = self.stack.enter_context(patch.object(market, '_bars', return_value=[
|
||
|
|
{'time': NOW.isoformat(), 'close': 10.0}]))
|
||
|
|
self.forbidden = []
|
||
|
|
for owner, name in ((requests, 'get'), (requests, 'post'), (requests, 'Session'),
|
||
|
|
(cache.db, 'execute'), (cache.db, 'fetch_one'), (cache.db, 'transaction'),
|
||
|
|
(cache.store, 'locked'), (cache.store, 'put_once'), (cache.store, 'stage_locked')):
|
||
|
|
self.forbidden.append(self.stack.enter_context(patch.object(owner, name,
|
||
|
|
side_effect=AssertionError('缓存消费禁止联网或写入'))))
|
||
|
|
|
||
|
|
def tearDown(self):
|
||
|
|
for method in self.forbidden:
|
||
|
|
method.assert_not_called()
|
||
|
|
|
||
|
|
def assert_no_legacy(self):
|
||
|
|
self.legacy.assert_not_called()
|
||
|
|
self.market_legacy.assert_not_called()
|
||
|
|
|
||
|
|
def test_valid_cache_keeps_content_version_and_source_metadata(self):
|
||
|
|
result = cache.get_limits(DAY, [A])
|
||
|
|
self.assertEqual(result[A], dict(record(), source='tushare.stk_limit', fetched_at=entry()['fetched_at']))
|
||
|
|
self.read.assert_called_once_with('price-limits:'+DAY)
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_shared_source_is_allowed_only_after_same_validation(self):
|
||
|
|
self.value['entries'][A]['source'] = 'gp_stk_limit'
|
||
|
|
self.assertEqual(cache.read_cache(DAY)[A]['source'], 'gp_stk_limit')
|
||
|
|
self.value['entries'][A]['record']['version'] = 'corrupt'
|
||
|
|
self.assertNotIn(A, cache.read_cache(DAY))
|
||
|
|
|
||
|
|
def test_envelope_wrong_date_or_structure_returns_no_value(self):
|
||
|
|
for value in (None, [], {'trade_date': '2026-11-02', 'entries': {A: entry()}},
|
||
|
|
{'trade_date': DAY, 'entries': []}, {'trade_date': DAY}):
|
||
|
|
with self.subTest(value_type=type(value).__name__):
|
||
|
|
self.value = value
|
||
|
|
self.assertEqual(cache.read_cache(DAY), {})
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_record_wrong_date_is_rejected_even_with_its_own_valid_hash(self):
|
||
|
|
self.value['entries'][A]['record'] = record(day='2026-11-02')
|
||
|
|
self.assertEqual(set(cache.read_cache(DAY)), {B})
|
||
|
|
|
||
|
|
def test_hash_corruption_or_changed_price_only_quarantines_affected_code(self):
|
||
|
|
good = entry()
|
||
|
|
for changed in ({**good['record'], 'version': 'bad'},
|
||
|
|
{**good['record'], 'up_limit': '12.00'},
|
||
|
|
{k: v for k, v in good['record'].items() if k != 'version'}):
|
||
|
|
self.value['entries'][A]['record'] = changed
|
||
|
|
self.assertEqual(set(cache.read_cache(DAY)), {B})
|
||
|
|
|
||
|
|
def test_bad_record_price_cannot_pass_by_preserving_previous_hash(self):
|
||
|
|
for changes in ({'pre_close': False}, {'up_limit': 0}, {'down_limit': 'NaN'}):
|
||
|
|
self.value['entries'][A]['record'] = {**record(), **changes}
|
||
|
|
self.assertEqual(set(cache.read_cache(DAY)), {B})
|
||
|
|
|
||
|
|
def test_source_status_and_fetched_timestamp_are_mandatory(self):
|
||
|
|
for changes in ({'source': 'computed'}, {'source': None}, {'status': 'UNSUPPORTED'},
|
||
|
|
{'status': 'FAILED'}, {'fetched_at': ''}, {'fetched_at': 'garbage'},
|
||
|
|
{'fetched_at': '2026-11-03T09:55:00'}, {'fetched_at': True},
|
||
|
|
{'fetched_at': (NOW-timedelta(days=1)).isoformat()},
|
||
|
|
{'fetched_at': (NOW+timedelta(seconds=1)).isoformat()}):
|
||
|
|
self.value['entries'][A] = entry(**changes)
|
||
|
|
self.assertEqual(set(cache.read_cache(DAY)), {B})
|
||
|
|
|
||
|
|
def test_timezone_conversion_checks_beijing_date(self):
|
||
|
|
self.value['entries'][A]['fetched_at'] = '2026-11-02T16:01:00+00:00'
|
||
|
|
self.assertIn(A, cache.read_cache(DAY))
|
||
|
|
self.value['entries'][A]['fetched_at'] = '2026-11-02T15:59:00+00:00'
|
||
|
|
self.assertNotIn(A, cache.read_cache(DAY))
|
||
|
|
|
||
|
|
def test_code_key_mismatch_and_beijing_rows_are_filtered(self):
|
||
|
|
self.value['entries'][A]['record'] = record(B)
|
||
|
|
self.value['entries'][BJ] = entry()
|
||
|
|
self.assertEqual(set(cache.read_cache(DAY)), {B})
|
||
|
|
self.assertEqual(cache.get_limits(DAY, [BJ]), {})
|
||
|
|
self.assertEqual(cache.get_limits(DAY, ['920001.SH']), {})
|
||
|
|
|
||
|
|
def test_unsupported_requested_codes_do_not_read_any_source(self):
|
||
|
|
self.assertEqual(cache.get_limits(DAY, [BJ, '430001.BJ']), {})
|
||
|
|
self.read.assert_not_called()
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_requested_filter_returns_only_selected_shanghai_shenzhen_codes(self):
|
||
|
|
self.assertEqual(set(cache.get_limits(DAY, [A, BJ])), {A})
|
||
|
|
self.assertEqual(set(cache.get_limits(DAY)), {A, B})
|
||
|
|
self.assertEqual(cache.get_limits(DAY, []), {})
|
||
|
|
|
||
|
|
def test_read_is_side_effect_free_and_does_not_extend_fetched_time(self):
|
||
|
|
original = copy.deepcopy(self.value)
|
||
|
|
first = cache.get_limits(DAY, [A])
|
||
|
|
first[A]['up_limit'] = '99.00'
|
||
|
|
self.assertEqual(self.value, original)
|
||
|
|
self.assertEqual(cache.get_limits(DAY, [A])[A]['fetched_at'], original['entries'][A]['fetched_at'])
|
||
|
|
self.assertEqual(cache.get_limits(DAY, [A])[A]['up_limit'], '11.00')
|
||
|
|
|
||
|
|
def test_every_read_observes_new_persisted_version_without_process_ttl(self):
|
||
|
|
old = cache.get_limits(DAY, [A])[A]
|
||
|
|
self.value['entries'][A]['record'] = record(high='11.01')
|
||
|
|
new = cache.get_limits(DAY, [A])[A]
|
||
|
|
self.assertNotEqual(old['version'], new['version'])
|
||
|
|
self.assertEqual(self.read.call_count, 2)
|
||
|
|
|
||
|
|
def test_cache_read_failure_never_falls_back_to_shared_table(self):
|
||
|
|
self.read.side_effect = RuntimeError('local store unavailable')
|
||
|
|
self.assertEqual(cache.get_limits(DAY, [A]), {})
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_feature_disabled_uses_old_source_and_filters_beijing(self):
|
||
|
|
self.enabled = False
|
||
|
|
self.legacy.return_value = [{'ts_code': A, 'up_limit': 11, 'down_limit': 9},
|
||
|
|
{'ts_code': BJ, 'up_limit': 11, 'down_limit': 9}]
|
||
|
|
result = cache.get_limits(DAY, [A, BJ])
|
||
|
|
self.assertEqual(set(result), {A})
|
||
|
|
sql, params = self.legacy.call_args.args
|
||
|
|
self.assertIn('gp_stk_limit', sql)
|
||
|
|
self.assertIn('ts_code IN', sql)
|
||
|
|
self.assertNotIn(BJ, params.values())
|
||
|
|
self.read.assert_not_called()
|
||
|
|
|
||
|
|
def test_market_consumer_uses_real_cache_and_preserves_metadata(self):
|
||
|
|
quote = market.execution_quote(A, now=NOW)
|
||
|
|
self.assertEqual((quote['limit_up'], quote['limit_down']), ('11.00', '9.00'))
|
||
|
|
self.assertEqual(quote['limit_source'], 'tushare.stk_limit')
|
||
|
|
self.assertEqual(quote['limit_version'], record()['version'])
|
||
|
|
self.assertEqual(quote['limit_fetched_at'], entry()['fetched_at'])
|
||
|
|
self.assertEqual(quote['source'], 'tushare:rt_min:1MIN')
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_price_order_keeps_exact_limit_source_version_and_fetch_time(self):
|
||
|
|
quote = market.execution_quote(A, now=NOW)
|
||
|
|
result = policy.price_order(side='buy', quote=quote, now=NOW)
|
||
|
|
self.assertEqual(result['action'], 'FIRE')
|
||
|
|
for key in ('limit_source', 'limit_version', 'limit_fetched_at'):
|
||
|
|
self.assertEqual(result[key], quote[key])
|
||
|
|
|
||
|
|
def test_market_missing_or_failed_cache_waits_without_old_source(self):
|
||
|
|
for fail in (False, True):
|
||
|
|
self.value = None
|
||
|
|
self.read.side_effect = RuntimeError('unavailable') if fail else lambda key: (None, 0)
|
||
|
|
quote = market.execution_quote(A, now=NOW)
|
||
|
|
self.assertIsNone(quote['limit_up'])
|
||
|
|
self.assertIsNone(quote['limit_down'])
|
||
|
|
self.assertIn(quote.get('limit_source'), (None, 'unknown', 'unavailable'))
|
||
|
|
self.assertEqual(policy.price_order(side='buy', quote=quote, now=NOW)['action'], 'WAIT')
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_market_feature_off_uses_original_sql_without_cache(self):
|
||
|
|
self.enabled = False
|
||
|
|
self.market_legacy.return_value = [{'up_limit': 11, 'down_limit': 9}]
|
||
|
|
quote = market.execution_quote(A, now=NOW)
|
||
|
|
self.assertEqual(quote['limit_up'], 11)
|
||
|
|
self.assertEqual(quote['limit_source'], 'gp_stk_limit')
|
||
|
|
self.assertIsNone(quote['limit_version'])
|
||
|
|
self.market_legacy.assert_called_once()
|
||
|
|
self.read.assert_not_called()
|
||
|
|
|
||
|
|
def test_market_rejects_beijing_before_loading_quotes_or_limits(self):
|
||
|
|
self.assertEqual(market.execution_quote(BJ, now=NOW), {})
|
||
|
|
self.bars.assert_not_called()
|
||
|
|
self.read.assert_not_called()
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_rotation_consumer_uses_actual_cache_and_reuses_validated_limits(self):
|
||
|
|
limits = rotation_service._limits(DAY)
|
||
|
|
self.assertEqual(set(limits), {A, B})
|
||
|
|
quote = market.execution_quote(A, now=NOW, limits=limits[A])
|
||
|
|
self.assertEqual(self.read.call_count, 1)
|
||
|
|
self.assertEqual(quote['limit_source'], 'tushare.stk_limit')
|
||
|
|
self.assertEqual(quote['limit_version'], limits[A]['version'])
|
||
|
|
self.assertEqual(policy.price_order(side='sell', quote=quote, now=NOW)['action'], 'FIRE')
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_rotation_missing_and_failed_cache_never_falls_back(self):
|
||
|
|
self.value = None
|
||
|
|
self.assertEqual(rotation_service._limits(DAY), {})
|
||
|
|
self.read.side_effect = RuntimeError('unavailable')
|
||
|
|
self.assertEqual(rotation_service._limits(DAY), {})
|
||
|
|
self.assert_no_legacy()
|
||
|
|
|
||
|
|
def test_rotation_feature_off_retains_old_source_with_exchange_sql_filter(self):
|
||
|
|
self.enabled = False
|
||
|
|
self.legacy.return_value = [{'ts_code': A, 'up_limit': 11, 'down_limit': 9}]
|
||
|
|
self.assertEqual(set(rotation_service._limits(DAY)), {A})
|
||
|
|
sql, params = self.legacy.call_args.args
|
||
|
|
self.assertIn('gp_stk_limit', sql)
|
||
|
|
self.assertIn("ts_code LIKE '60____.SH'", sql)
|
||
|
|
self.assertIn("ts_code LIKE '30____.SZ'", sql)
|
||
|
|
self.assertEqual(params['day'], DAY)
|
||
|
|
self.read.assert_not_called()
|
||
|
|
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
unittest.main(verbosity=2)
|