154 lines
8.2 KiB
Python
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()
|