"""异步研判的持久化、迟到隔离与真实行情来源边界。""" import unit_test_guard import contextlib import copy import unittest from datetime import datetime, timedelta, timezone from unittest.mock import patch, Mock from test_wiring import install_fakes from app.services import judge_async as ja, market, judge NOW = datetime(2026,11,3,10,0,tzinfo=timezone(timedelta(hours=8))) class AsyncJudgeTests(unittest.TestCase): def setUp(self): self.fake = install_fakes(params={'PMS_JUDGE_ASYNC_ENABLED':True}) self.docs = {} @contextlib.contextmanager def locked(key, kind, initial): value = copy.deepcopy(self.docs.get(key, initial)) yield value self.docs[key] = value patch.object(ja.repo,'locked',locked).start() patch.object(ja.repo,'recent',side_effect=lambda *a:[{'value':v} for v in self.docs.values()]).start() self.post = patch('requests.post',side_effect=self.submit).start() self.get = patch('requests.get',side_effect=self.poll).start() self.state = 'PENDING' self.c = {'ts_code':'600000.SH','action':'OPEN','qty':100,'hard_numbers':{'plan_basis':{'logic':'stable'}}} self.payload = {'direction':'PMS_JUDGE','ts_code':'600000.SH','action':'OPEN','qty':100, 'hard_numbers':{'price':10}, 'context':{'position':{'total_qty':0}}} self.addCleanup(patch.stopall) def response(self, data): return Mock(json=lambda:data,raise_for_status=lambda:None) def submit(self, url, json, **kw): self.sent = json return self.answer() def poll(self, *a, **kw): return self.answer() def answer(self): return self.response({'verdict':self.state, 'request_id':self.sent['request_id'], 'evidence_fingerprint':self.sent['evidence_fingerprint'],'reason':'test'}) def ask(self, now=NOW): return ja.request(self.c, self.payload, 'http://stub', now) def test_register_then_poll_without_duplicate_model(self): self.assertEqual(self.ask()['verdict'],'PENDING') self.state='PASS' self.assertEqual(self.ask(NOW+timedelta(seconds=10))['verdict'],'PASS') self.assertEqual((self.post.call_count,self.get.call_count),(1,1)) def test_price_and_quantity_noise_reuses_original_evidence(self): self.ask() self.payload['hard_numbers']['price']=10.8 self.payload['qty']=300 self.ask(NOW+timedelta(seconds=10)) self.assertEqual(self.post.call_count,1) self.assertEqual(self.sent['hard_numbers']['price'],10) def test_changed_research_creates_new_request(self): self.ask(); old=self.sent['request_id'] self.c['hard_numbers']['plan_basis']['logic']='changed' self.ask(NOW+timedelta(seconds=10)) self.assertNotEqual(self.sent['request_id'],old) def test_changed_actual_holding_creates_new_request(self): self.ask();old=self.sent['request_id'] self.payload['context']['position']['total_qty']=100 self.ask(NOW+timedelta(seconds=10)) self.assertNotEqual(self.sent['request_id'],old) def test_deadline_includes_queue_and_never_polls_late(self): self.ask();self.state='PASS' result=self.ask(NOW+timedelta(seconds=121)) self.assertEqual(result['verdict'],'UNAVAILABLE') self.get.assert_not_called() def test_wrong_fingerprint_never_authorizes(self): self.ask() self.get.side_effect=lambda *a,**kw:self.response({'verdict':'PASS', 'request_id':self.sent['request_id'],'evidence_fingerprint':'wrong'}) self.assertEqual(self.ask(NOW+timedelta(seconds=10))['verdict'],'UNAVAILABLE') def test_cached_result_is_reused_without_http(self): self.state='PASS';self.ask();self.ask(NOW+timedelta(seconds=10)) self.assertEqual(self.post.call_count,1);self.get.assert_not_called() def test_late_old_response_cannot_replace_new_request(self): self.ask() def replace(*a,**kw): for doc in self.docs.values(): doc['request_id']='new_request' self.state='PASS' return self.answer() self.get.side_effect=replace self.assertEqual(self.ask(NOW+timedelta(seconds=10))['verdict'],'UNAVAILABLE') self.assertEqual(next(iter(self.docs.values()))['request_id'],'new_request') def test_reask_survives_next_scan_and_retains_manual_confirmation(self): self.c['reask']={'why':'changed','hits':['price']} self.payload['force_refresh']=True self.ask() self.assertIn(('600000.SH','OPEN'),ja.resumable_reasks(NOW)) self.c.pop('reask');self.payload.pop('force_refresh');self.state='PASS' self.ask(NOW+timedelta(seconds=10)) self.assertIn('reask',self.c) self.assertFalse(ja.resumable_reasks(NOW)) def test_beijing_code_does_not_reach_storage_or_network(self): self.payload['ts_code']='920001.BJ' self.assertEqual(self.ask()['verdict'],'UNAVAILABLE') self.post.assert_not_called();self.assertEqual(self.docs,{}) def test_persist_failure_never_sends(self): with patch.object(ja.repo,'locked',side_effect=RuntimeError('db')): self.assertEqual(self.ask()['verdict'],'UNAVAILABLE') self.post.assert_not_called() def test_network_timeout_keeps_pending_and_original_request(self): import requests self.post.side_effect=requests.Timeout('test') self.assertEqual(self.ask()['verdict'],'PENDING') old=next(iter(self.docs.values()))['request_id'] self.post.side_effect=self.submit self.ask(NOW+timedelta(seconds=10)) self.assertEqual(self.sent['request_id'],old) def test_expired_request_does_not_requeue_same_evidence(self): self.ask();self.ask(NOW+timedelta(seconds=121)) self.assertEqual(self.ask(NOW+timedelta(seconds=601))['verdict'],'UNAVAILABLE') self.assertEqual(self.post.call_count,1) def test_async_dry_run_never_registers(self): from app.services import proposal_service as ps c={'ts_code':'600000.SH','action':'OPEN','side':'buy','qty':100,'price':10, 'reason':'test','hard_numbers':{},'judge_required':True} out={k:[] for k in ('skipped','rejected','queued','executed')} with patch.object(ps,'check_candidate_rules',return_value={'passed':True}), \ patch.object(ps.judge,'request',side_effect=AssertionError('试算不得登记')), \ patch.object(ps,'_recent_ledger',return_value=[]): ps._route_one(c,{'positions':[]},{},{},False,NOW,True,out) self.assertFalse(self.docs) def test_rotation_pending_includes_daily_review_parents(self): from app.services import rotation_execution self.fake.insert_instruction(instruction_id='REVIEW',origin_type='plan',origin_id='plan', ts_code='600000.SH',action='OPEN',side='buy',qty=100,status='WAIT_REVIEW',progress={}) with patch.object(rotation_execution.qmt_repo,'list_orders',return_value=[]): self.assertIn('REVIEW',[x['instruction_id'] for x in rotation_execution.pending_instructions()]) def test_client_scope_gets_separate_local_request(self): self.payload['client_scope']='first';self.ask();old=self.sent['request_id'] self.payload['client_scope']='second';self.ask() self.assertNotEqual(old,self.sent['request_id']) self.assertEqual(len(self.docs),2) def test_pending_route_is_neither_pass_nor_manual_proposal(self): from app.services import proposal_service as ps c={'ts_code':'600000.SH','action':'OPEN','side':'buy','qty':100,'price':10, 'reason':'test','hard_numbers':{},'judge_required':True} out={k:[] for k in ('skipped','rejected','queued','executed')} with patch.object(ps,'check_candidate_rules',return_value={'passed':True}), \ patch.object(ps.judge,'request',return_value={'verdict':'PENDING','reason':'waiting'}), \ patch.object(ps,'_recent_ledger',return_value=[]): ps._route_one(c,{'positions':[]},{},{},False,NOW,False,out) self.assertEqual(out['skipped'][0]['by'],'judge_pending') self.assertEqual(out['queued']+out['executed']+out['rejected'],[]) class SchedulerEntryTests(unittest.TestCase): def setUp(self): from app import scheduler from app.services import executor, proposal_service, strategy_runner, daily_buy_review, execution_basis self.sch = scheduler self.fake = install_fakes(params={'PMS_JUDGE_ASYNC_ENABLED':True, 'PMS_EXEC_REPRICE_ENABLED':True}) patch.object(scheduler.td,'is_trade_day',return_value=True).start() patch.object(scheduler,'in_session',return_value=True).start() self.model = patch.object(proposal_service,'scan_and_route',return_value={'ok':True}).start() self.review = patch.object(daily_buy_review,'process',return_value={'waiting':[]}).start() self.refresh = patch.object(execution_basis,'refresh',return_value={'enabled':True}).start() self.monitor = patch.object(execution_basis,'monitor',return_value={'cancelled':[]}).start() patch.object(executor,'materialize_plans',return_value={}).start() patch.object(executor,'sweep_windows',return_value={}).start() patch.object(executor,'run_tick',return_value={'fired':[]}).start() patch.object(strategy_runner,'tick',return_value={}).start() self.addCleanup(patch.stopall) def test_async_execution_entry_does_not_scan_judgements(self): result = self.sch.intraday_exec.run() self.assertNotIn('error',result) self.assertEqual(result['fired'],[]) self.model.assert_not_called();self.review.assert_not_called() self.monitor.assert_called_once_with() def test_legacy_execution_entry_keeps_proposals_and_daily_review(self): self.fake.params['PMS_JUDGE_ASYNC_ENABLED']=False result=self.sch.intraday_exec.run() self.assertNotIn('error',result) self.model.assert_called_once_with();self.review.assert_called_once_with() def test_async_proposal_entry_runs_its_own_daily_review(self): result=self.sch.proposal_scan.run() self.assertTrue(result['ok']) self.review.assert_called_once_with();self.model.assert_called_once_with() def test_basis_refresh_entry_uses_new_flag(self): self.assertEqual(self.sch.execution_basis_refresh.run(),{'enabled':True}) self.refresh.assert_called_once_with() def test_cancel_confirm_entry_continues_under_global_halt(self): self.fake.params['PMS_GLOBAL_EXEC_HALT']=True with patch.object(self.sch,'in_session',return_value=False): self.assertEqual(self.sch.execution_cancel_confirm.run(),{'cancelled':[]}) self.monitor.assert_called_once_with(cancel_only=True) self.model.assert_not_called();self.refresh.assert_not_called() class QuoteTests(unittest.TestCase): def test_minute_quote_keeps_unknown_halt_and_no_invented_level1(self): with patch.object(market,'_bars',return_value=[{'time':'2026-11-03 09:59:00','close':10}]): q=market.execution_quote('600000.SH',NOW,{'up_limit':11,'down_limit':9}) self.assertEqual(q['kind'],'minute');self.assertIsNone(q['halted']) self.assertIsNone(q['ask']);self.assertEqual(q['as_of'],'2026-11-03T09:59:00+08:00') def test_missing_date_cannot_be_filled_with_today(self): with patch.object(market,'_bars',return_value=[{'time':'09:59:00','close':10}]): self.assertEqual(market.execution_quote('600000.SH',NOW,{}),{}) if __name__=='__main__': unittest.main()