import unit_test_guard import sys from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parents[1])) import signal import types import unittest from unittest.mock import patch, Mock from app import market_data_worker as worker from app import services from app.services import param_store from config.settings import settings class WorkerChecks(unittest.TestCase): def test_invalid_limit_flags_fail_closed_without_database_write(self): rows = {key: {'param_value': 'invalid'} for key in param_store.LIMIT_FLAGS} with patch.object(param_store, 'refresh', return_value=rows), \ patch.object(param_store.pms_repo, 'set_param') as write: self.assertTrue(param_store.get_bool('PMS_LIMIT_CACHE_ENABLED')) self.assertFalse(param_store.get_bool('PMS_LIMIT_COLLECT_ENABLED')) self.assertFalse(param_store.set_param('PMS_LIMIT_CACHE_ENABLED', 'invalid')['ok']) write.assert_not_called() def test_shutdown_finishes_current_round_and_does_not_run_again(self): callbacks = {} event = Mock() stopped = [False] event.is_set.side_effect = lambda: stopped[0] event.set.side_effect = lambda: stopped.__setitem__(0, True) module = types.ModuleType('app.services.price_limit_collector') def run(): callbacks[signal.SIGTERM](signal.SIGTERM, None) return {'status':'done','day':'2026-11-03','target_count':3,'valid_count':2,'missing_count':1,'error_count':0, 'private':'must-not-log'} module.run_once = Mock(side_effect=run) with patch.object(services,'price_limit_collector',module,create=True), \ patch.object(worker,'Event',return_value=event), \ patch.object(worker.signal,'signal',side_effect=lambda name,callback: callbacks.__setitem__(name,callback)), \ patch.object(worker.logging,'basicConfig'), self.assertLogs(worker.logger,level='INFO') as logs: worker.main() module.run_once.assert_called_once_with() event.wait.assert_called_once_with(10) self.assertIn(signal.SIGINT,callbacks) self.assertNotIn('must-not-log',str(logs.output)) self.assertIn('missing_count=1',str(logs.output)) def test_failure_logs_type_only_and_next_round_runs(self): module = types.ModuleType('app.services.price_limit_collector') module.run_once = Mock(side_effect=[RuntimeError('private token and address'), {'status':'done'}]) event = Mock() event.is_set.side_effect = [False,False,True] with patch.object(services,'price_limit_collector',module,create=True), \ patch.object(worker,'Event',return_value=event), \ patch.object(worker.signal,'signal'), patch.object(worker.logging,'basicConfig'), \ self.assertLogs(worker.logger,level='INFO') as logs: worker.main() self.assertEqual(module.run_once.call_count,2) self.assertEqual(event.wait.call_count,2) self.assertIn('RuntimeError',str(logs.output)) self.assertNotIn('private token',str(logs.output)) def test_summary_rejects_unsanitized_fields(self): value=worker._summary({'status':{'token':'secret'},'day':'secret', 'target_count':'secret','valid_count':True,'missing_count':-1,'error_count':4}) self.assertEqual(value,('unknown','-',0,0,0,4)) with self.assertRaises(ValueError):worker._summary([]) def test_token_is_environment_only_and_absent_from_snapshot(self): self.assertEqual(settings.PMS_TUSHARE_TOKEN,'') self.assertIn('PMS_TUSHARE_TOKEN',param_store.SECRET_KEYS) self.assertNotIn('PMS_TUSHARE_TOKEN',param_store.RUNTIME_EXTRA) self.assertNotIn('PMS_TUSHARE_TOKEN',param_store._editable_keys()) with patch.object(param_store,'refresh',return_value={}) as refresh: self.assertEqual(param_store.get('PMS_TUSHARE_TOKEN'),'') refresh.assert_not_called() self.assertNotIn('PMS_TUSHARE_TOKEN',{p['key'] for p in param_store.snapshot()['params']}) self.assertFalse(param_store.set_param('PMS_TUSHARE_TOKEN','private')['ok']) def test_defaults_types_ranges_and_collection_window(self): expected={'PMS_LIMIT_CACHE_ENABLED':(False,None),'PMS_LIMIT_COLLECT_ENABLED':(False,None), 'PMS_LIMIT_FETCH_TIMEOUT_SEC':(5,(1,10)), 'PMS_LIMIT_ROUND_BUDGET_SEC':(30,(5,60)), 'PMS_LIMIT_ROUND_MAX_CODES':(25,(1,60)), 'PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC':(1.2,(1,10)), 'PMS_LIMIT_RETRY_BASE_SEC':(60,(30,600)), 'PMS_LIMIT_RETRY_MAX_SEC':(900,(60,3600)), 'PMS_LIMIT_MAX_FAILURES_PER_DAY':(32,(1,100)), 'PMS_LIMIT_REFRESH_SEC':(900,(300,7200)), 'PMS_LIMIT_COLLECT_START':('08:55',None),'PMS_LIMIT_COLLECT_END':('18:00',None)} for key,(default,bounds) in expected.items(): self.assertEqual(getattr(settings,key),default) self.assertEqual(param_store.RUNTIME_EXTRA[key][:2],(default,type(default))) if bounds: self.assertEqual(param_store._RANGES[key],bounds) lo,hi=bounds self.assertIsNone(param_store._range_check(key,lo)) self.assertIsNone(param_store._range_check(key,hi)) self.assertIsNotNone(param_store._range_check(key,lo-1)) self.assertIsNotNone(param_store._range_check(key,hi+1)) if __name__=='__main__':unittest.main()