tradingSystem/scripts/test_batch57_units.py

188 lines
8.9 KiB
Python

"""异步研判的持久化、迟到隔离与真实行情来源边界。"""
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 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()