tradingSystem/scripts/test_price_limit_cache.py

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)