tradingSystem/scripts/test_plan_rank_boundary.py

154 lines
8.2 KiB
Python

"""逐票核验须穿过普通发现窗口,同时保留原有资格条件。"""
import unit_test_guard # noqa: F401
import json
import sys
import unittest
from datetime import datetime
from pathlib import Path
from unittest.mock import patch
import requests
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core.plan_revision import basis, fingerprint, portfolio_context
from app.repo import pms_repo
from app.services import plan_feed, plan_recheck, portfolio, proposal_service
from test_wiring import install_fakes
CODE = '603999.SH'
UPSTREAM_CODE = 'SH603999'
class PlanRankBoundaryTest(unittest.TestCase):
def setUp(self):
fake = install_fakes(prices={CODE: 10}, positions=[], params={
'PMS_PLAN_API_BASE': 'http://bridge.invalid', 'PMS_PLAN_TOP': '300',
'PMS_CONSENSUS_ROUTE': 'false', 'PMS_PLAN_BY_ADVICE': 'false',
'PMS_PLAN_TOP_N': '50', 'PMS_PLAN_SNAPSHOT': 'false',
'PMS_PLAN_THEME_CAP_LOCAL': '0', 'PMS_PLAN_VERSION_RECHECK': 'true',
})
fake.qmt.put_snapshot(kind='funds', data={'total_asset': 2000000, 'available_cash': 2000000})
self.date = datetime.now().date().isoformat()
self.row = {'code': UPSTREAM_CODE, 'name': '样本', 'research_rank': 301, 'rank': 301,
'tier': '强传导', 'score': 231, 'verdict': '候选'}
self.plan = {'date': self.date, 'main': [self.row], 'observe': [],
'rank_axis': 'quality', 'decision': {'id': 'published-v2'}}
self.ordinary = [dict(self.row, code=f'SH{600000+i}', rank=i+1, research_rank=i+1)
for i in range(300)]
self.plan['main'] = self.ordinary + [self.row]
plan_feed.invalidate()
self.addCleanup(plan_feed.invalidate)
self.http = self.enterContext(patch('requests.get', side_effect=self.response))
self.record = self.enterContext(patch.object(pms_repo, 'insert_plan_snapshot', return_value=1))
old = dict(self.plan, decision={'id': 'published-v1'}, main=[dict(self.row, rank=1, research_rank=1)])
selected = plan_feed.select_candidates(plan_feed.parse_plan(old))['items'][0]
self.view = portfolio.positions_view()
self.params = proposal_service._scan_params(self.view)
self.hard = {'decision': old['decision'], 'consumption_id': 'original-consumption',
'plan_basis': basis(selected), 'scan_params_hash': fingerprint(self.params),
'portfolio_context_hash': portfolio_context(self.view,
proposal_service._inflight_open_commitments(self.view))}
def response(self, url, params, timeout):
if url.endswith('/check'):
self.assertEqual(params, {'code': CODE, 'include_user_candidates': 1})
rows = [r for r in self.plan['main'] if r['code'] == UPSTREAM_CODE]
result = dict(self.plan, main=rows, check_code=UPSTREAM_CODE, found=bool(rows))
else:
self.assertEqual(url, 'http://bridge.invalid/plan')
count = int(params['top'])
self.assertEqual(count, 300)
result = dict(self.plan, main=self.plan['main'][:count])
reply = requests.Response()
reply.status_code = 200
reply.encoding = 'utf-8'
reply._content = json.dumps(result, ensure_ascii=False).encode('utf-8')
return reply
def test_current_rank_301_preserves_qualification_across_routes(self):
discovery = plan_feed.candidates(record=False)
self.assertNotIn(CODE, [r['ts_code'] for r in discovery['items']])
fast = plan_recheck.current_basis(self.hard, CODE, record=False)
self.assertTrue(fast['ok'], fast)
self.record.assert_not_called()
automatic = proposal_service.verify_open_basis(self.hard, CODE)
self.assertTrue(automatic['ok'], automatic)
self.assertEqual(automatic['provenance']['consumption_id'], fast['provenance']['consumption_id'])
prepared = plan_recheck.prepare_new(self.hard, CODE, {'verdict': 'PASS'})
self.assertEqual(prepared['preparation']['status'], 'ready')
self.assertEqual(self.record.call_count, 2)
for receipt in self.record.call_args_list:
self.assertEqual(receipt.kwargs['meta']['kind'], 'rechecked')
self.assertEqual(receipt.kwargs['meta']['order'], [CODE])
self.assertEqual(receipt.kwargs['meta']['decision'], self.plan['decision'])
recorded = receipt.kwargs['roster'][0]
self.assertEqual(recorded['research_rank'], 301)
self.assertNotIn('selection_rank', recorded)
def test_background_refresh_reprices_one_stock_outside_the_discovery_window(self):
hard = dict(self.hard, preparation={'status': 'pending'}, proposal_revision='v1-shown',
prepared_judgement={'verdict': 'PASS', 'confidence': 80, 'degraded': False})
proposal = {'proposal_id': 'pending', 'ts_code': CODE, 'action': 'OPEN', 'qty': 100,
'hard_numbers': hard}
with patch.object(pms_repo, 'record_proposal_check', return_value=1), \
patch.object(pms_repo, 'publish_prepared_proposal', return_value=1) as publish:
result = plan_recheck.refresh_one(proposal)
self.assertTrue(result['ok'], result)
saved = publish.call_args.args[1]['hard_numbers']
self.assertEqual(saved['preparation']['status'], 'ready')
self.assertEqual(saved['research_rank'], 301)
for key in ('selection_rank', 'execution_rank', 'priority_reason'):
self.assertNotIn(key, saved)
self.assertEqual(self.http.call_count, 3)
def test_report_published_between_two_checks_requires_a_new_judgement(self):
hard = dict(self.hard, preparation={'status': 'pending'}, proposal_revision='v1-shown',
prepared_judgement={'verdict': 'PASS', 'reason': '基于旧评析', 'confidence': 80})
proposal = {'proposal_id': 'pending', 'ts_code': CODE, 'action': 'OPEN', 'qty': 100,
'hard_numbers': hard}
def publish_new_report(url, params, timeout):
if self.http.call_count == 2:
self.plan['decision'] = {'id': 'published-v3'}
self.row['company_review_text'] = '新的买方评析'
return self.response(url, params, timeout)
self.http.side_effect = publish_new_report
new_judgement = {'verdict': 'PASS', 'reason': '已核验新评析', 'confidence': 80, 'raw': {}}
with patch.object(pms_repo, 'record_proposal_check', return_value=1), \
patch.object(pms_repo, 'publish_prepared_proposal', return_value=1) as publish, \
patch.object(proposal_service.judge, 'request', return_value=new_judgement) as judge:
result = plan_recheck.refresh_one(proposal)
self.assertTrue(result['ok'], result)
judge.assert_called_once()
self.assertTrue(judge.call_args.kwargs['force'])
self.assertEqual(publish.call_args.args[2]['reason'], '已核验新评析')
self.assertEqual(publish.call_args.args[1]['hard_numbers']['decision']['id'], 'published-v3')
def test_absent_in_complete_version_is_a_real_qualification_loss(self):
self.plan['main'] = self.ordinary
for record in (False, True):
self.assertTrue(plan_recheck.current_basis(self.hard, CODE, record=record)['withdraw'])
self.plan['refresh_status'] = {'pending_codes': [UPSTREAM_CODE]}
retry = plan_recheck.current_basis(self.hard, CODE, record=True)
self.assertFalse(retry['ok'])
self.assertEqual(retry['stage'], 'research_pending')
self.assertFalse(retry.get('withdraw'))
def test_material_change_or_record_failure_blocks_automatic_approval(self):
self.row['risk'] = ['新增风险']
changed = proposal_service.verify_open_basis(self.hard, CODE)
self.assertFalse(changed['ok'])
self.assertTrue(changed['research_changed'])
self.record.side_effect = RuntimeError('核验账本写入失败')
blocked = proposal_service.verify_open_basis(self.hard, CODE)
self.assertFalse(blocked['ok'])
self.assertEqual(blocked['stage'], 'record')
self.assertFalse(blocked.get('withdraw'))
if __name__ == '__main__':
unittest.main()