"""限制价缓存及普通、微盘消费入口的隔离回归。无外部访问或状态写入。""" 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)