akg-factor-bridge/test_user_candidates.py

200 lines
12 KiB
Python
Raw Normal View History

"""用户候选登记、原有门槛与版本闭环的断网回归。"""
import copy
import datetime as dt
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch, Mock
from contextlib import ExitStack
import pandas as pd
import test_api_support
import user_candidates as uc
import plan, config, card, sources, factors, judgement, logic_state_daily
import plan_inputs as pi
import plan_versions as pv
import plan_refresh
import user_research
NOW = dt.datetime.fromisoformat('2026-11-03T10:00:00+08:00')
DAY = '2026-11-02'
PAYLOAD = {'codes': ['600001.SH'], 'reason': '行业需求变化', 'expires_on': '2026-11-10'}
USER_NAMES = dict(zip(
['SZ300133', 'SZ300364', 'SZ300182', 'SH603533', 'SZ300291', 'SZ301052'],
['华策影视', '中文在线', '捷成股份', '掌阅科技', '百纳千成', '果麦文化']))
class CandidateTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.root = self.temp.name
self.addCleanup(self.temp.cleanup)
self.reports = patch.object(user_research, 'load_reports', return_value={})
self.reports.start()
self.addCleanup(self.reports.stop)
def test_exchange_validation_batch_atomic_and_dedup(self):
for code in ('830001.BJ', '920001', 'SH000001', 'SZ600001', '123', '510300.SH'):
with self.assertRaises(ValueError):
uc.save(self.root, dict(PAYLOAD, codes=['600001', code]), '甲', NOW)
self.assertEqual(uc.read(self.root)['rows'], [])
r = uc.save(self.root, dict(PAYLOAD, codes=['600001', 'SH600001', '600001.SH']), '甲', NOW)
self.assertEqual(r['added'], 1)
self.assertEqual(uc.save(self.root, PAYLOAD, '乙', NOW)['existing'], 1)
self.assertEqual(uc.read(self.root)['rows'][0]['created_by'], '甲')
def test_pasted_names_mixed_codes_and_separators_save_canonical_codes(self):
text = '华策影视 中文在线,捷成股份\n掌阅科技;百纳千成、果麦文化'
result = uc.save(self.root, dict(PAYLOAD, codes=[text, '300133.SZ']), '甲', NOW, names=USER_NAMES)
self.assertEqual(result['added'], 6)
self.assertEqual([r['code'] for r in uc.read(self.root)['rows']], list(USER_NAMES))
self.assertEqual([r['name'] for r in uc.listing(self.root, NOW)['rows']], list(USER_NAMES.values())[::-1])
self.assertEqual(uc.save(self.root, dict(PAYLOAD, codes=text), '甲', NOW, names=USER_NAMES)['existing'], 6)
def test_unmatched_or_ambiguous_name_does_not_partially_save(self):
names = dict(USER_NAMES, SH600001='同名', SZ000001='同名')
for value, message in [('华策影视 不存在的股票', '未找到沪深 A 股'),
('华策影视 同名', '对应多只股票'),
('华策影视 中文', '未找到沪深 A 股'),
('华策影视 920001', '仅支持沪深 A 股'),
(' '.join(['华策影视'] * 31), '1 至 30')]:
with self.assertRaisesRegex(ValueError, message):
uc.save(self.root, dict(PAYLOAD, codes=[value]), '甲', NOW, names=names)
self.assertFalse(Path(self.root, 'user_candidates.json').exists())
def test_catalog_reads_full_listed_shanghai_shenzhen_universe(self):
import db
rows = [{'gp_code_two': c[2:]+'.'+c[:2], 'gp_name': n} for c, n in USER_NAMES.items()]
rows += [{'gp_code_two': '920001.BJ', 'gp_name': '排除示例'}, {'gp_code_two': '510300.SH', 'gp_name': '基金示例'}]
with patch.object(db, 'read_mysql', return_value=pd.DataFrame(rows)) as read:
self.assertEqual(uc.catalog(), USER_NAMES)
self.assertEqual(read.call_args.args[0], 'heat')
self.assertIn("list_status='L'", read.call_args.args[1])
self.assertIn("gp_code_two LIKE '%.SH' OR gp_code_two LIKE '%.SZ'", read.call_args.args[1])
def test_search_and_add_use_full_catalog_without_industry_membership(self):
import api
with patch.object(config, 'XXL_TRIGGER_KEY', 'test-secret'), patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root), \
patch.object(uc, 'catalog', return_value=USER_NAMES), patch.object(plan, '_names', side_effect=AssertionError('不能依赖行业池')):
self.assertEqual(api.search_user_candidates('中文在线')['items'], [{'code': 'SZ300364', 'name': '中文在线'}])
background = Mock()
expiry = (dt.datetime.now(uc.BJ).date() + dt.timedelta(days=1)).isoformat()
result = api.add_user_candidates(background, dict(PAYLOAD, codes=list(USER_NAMES.values()), expires_on=expiry), x_job_key='test-secret')
self.assertEqual(result['added'], 6)
background.add_task.assert_called_once_with(uc.refresh_saved)
def test_expiry_remove_and_readd_do_not_erase_history(self):
uc.save(self.root, PAYLOAD, '甲', NOW)
old = uc.active(self.root, NOW)[0]
pub = {'user_candidates': [old]}
uc.remove(self.root, old['id'], '甲', NOW)
self.assertEqual(uc.live_pending(self.root, pub, NOW), ['SH600001'])
self.assertEqual(uc.remove(self.root, old['id'], '甲', NOW)['revision'], 2)
uc.save(self.root, PAYLOAD, '甲', NOW)
self.assertNotEqual(uc.active(self.root, NOW)[0]['id'], old['id'])
self.assertEqual(len(uc.read(self.root)['rows']), 2)
later = NOW + dt.timedelta(days=8)
self.assertEqual(uc.active(self.root, later), [])
def test_manual_discovery_never_fakes_transmission_or_other_gates(self):
evidence = {'pointed': False, 'user_selected': True, 'pct0': 4,
'covered': True, 'upside': .2, 'accum_state': '明确吸筹', 'accum_age': 0}
result = card.judge(evidence)
self.assertEqual(result['verdict'], card.VERDICT_CANDIDATE)
self.assertFalse(result['gates']['pointed'])
for change in ({'covered': False}, {'upside': -.2}, {'risk_name': True},
{'pct0': 0}, {'y_signal': 'SELL'}, {'accum_state': '潜在吸筹'}):
self.assertEqual(card.judge(dict(evidence, **change))['verdict'], card.VERDICT_SHOW)
self.assertEqual(card.judge(dict(evidence, user_selected=False))['verdict'], card.VERDICT_SHOW)
def test_mutations_require_key_and_do_not_publish_inline(self):
import api
with patch.object(config, 'XXL_TRIGGER_KEY', 'test-secret'), patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root):
with self.assertRaises(api.HTTPException):
api.add_user_candidates(None, PAYLOAD, x_job_key='bad')
self.assertFalse(Path(self.root, 'user_candidates.json').exists())
def test_old_consumers_exclude_user_source_before_top_and_cache_is_separate(self):
import api
source={'id':'a'*32,'code':'SH600001'}
row={'code':'SH600001','score':250,'rank':1,'research_rank':1,'evidence':{},
'user_candidate':source,'user_required':True,'verdict':'候选'}
ordinary={'code':'SH600002','score':240,'rank':2,'research_rank':2,'evidence':{},'verdict':'候选'}
published={'date':DAY,'decision':{'id':'v-opt-in'},'main':[row,ordinary],'observe':[],
'user_candidates':[source],'candidates':[row,ordinary],'watch':[],
'counts':{'main':2,'observe':0}}
original=copy.deepcopy(published)
with patch.object(config,'PLAN_SNAPSHOT_DIR',self.root),patch.object(pv,'load',return_value=published):
default,_=api._plan_cached(DAY,1,0,0,True)
opted,_=api._plan_cached(DAY,1,0,0,True,include_user_candidates=True)
again,hit=api._plan_cached(DAY,1,0,0,False)
self.assertEqual(default['main'][0]['code'],'SH600002')
self.assertEqual(opted['main'][0]['code'],'SH600001')
self.assertEqual(default,again)
self.assertTrue(hit)
self.assertNotIn('user_candidates',default)
self.assertEqual(default['counts']['main'],1)
self.assertEqual(len(default['candidates']),1)
self.assertEqual(original,published)
def test_revision_add_remove_replay_and_frozen_morning(self):
codes = ['SH600001', 'SH600002']
with ExitStack() as stack:
def stub(obj, name, **kw): return stack.enter_context(patch.object(obj, name, **kw))
stub(config, 'PLAN_SNAPSHOT_DIR', new=self.root)
stub(config, 'PLAN_RANK_AXIS', new='quality')
stub(plan, '_factor', side_effect=lambda table, day: pd.Series(
[240.,230.] if 'score' in table else [.3,.2] if 'upside' in table else [2.,2.], index=codes))
stub(plan, '_latest_date', return_value=DAY)
stub(plan, '_prev_date', return_value=None)
stub(plan, '_names', return_value={'SH600001':'甲','SH600002':'乙'})
stub(uc, 'catalog', return_value={'SH600001':'甲','SH600002':'乙','SH600003':'丙'})
stub(plan, '_evidence', return_value=({}, {DAY}))
stub(plan, '_segments_of', return_value={})
stub(factors, '_risk_set', return_value=set())
stub(judgement, 'load_previous', return_value=[])
stub(judgement, 'recent_rows', return_value={})
stub(logic_state_daily, 'history', return_value={})
for name in ('moved_members','broker_reports','logic_claims','broker_actions','close_prices',
'valuation_scenarios','analyst_events','event_day_fields','news_flashes',
'segment_catalysts','catalysts_for_codes'):
stub(sources, name, return_value={})
stub(sources, 'stock_daily', return_value={c:{'pct0':4} for c in codes})
stub(sources, 'night_conclusions', return_value={c:{'accum_state':'明确吸筹','accum_age':0} for c in codes})
stub(sources, 'company_reviews', side_effect=lambda cs,*a,**kw: {c:{'overall':'好','age_days':0,'review_ref':'r'} for c in cs})
bundle = pi.Bundle(params=pi.effective_config(config), cutoff_at='2026-11-03T07:10:00+08:00')
with bundle.use():
data = plan.collect(DAY)
data.update(data.pop('_full'))
with pv.writer(self.root):
morning = pv.publish(self.root,data,{'records':bundle.records,'market':{},'regime':None},
bundle.params,cutoff_at=bundle.cutoff_at,reason='晨版')
frozen = copy.deepcopy(morning)
uc.save(self.root,dict(PAYLOAD,codes=['600001','600003']), '甲', NOW)
self.assertEqual(pv.stock_check(self.root,'SH600001')['refresh_status']['pending_codes'],['SH600001','SH600003'])
result = plan_refresh.refresh(now=NOW)
self.assertEqual(result['status'],'published')
published = pv.load(self.root)
rows = {r['code']:r for r in published['main']}
self.assertEqual(rows['SH600001']['verdict'],'候选')
self.assertFalse(rows['SH600001']['pointed'])
self.assertEqual(rows['SH600001']['score'],240.)
self.assertIsNone(rows['SH600003']['score'])
self.assertEqual(rows['SH600003']['name'], '丙')
self.assertNotIn('tier',rows['SH600003'])
self.assertFalse(pv.stock_check(self.root,'SH600003')['found'])
self.assertTrue(pv.stock_check(self.root,'SH600003',include_user_candidates=True)['found'])
json.dumps(published,allow_nan=False)
self.assertIn('SH600003', Path(self.root, f'plan_{DAY}.md').read_text())
self.assertEqual(pv.load(self.root,DAY,morning=True),frozen)
self.assertEqual(plan_refresh.refresh(now=NOW)['status'],'unchanged')
for source in uc.active(self.root,NOW):
uc.remove(self.root,source['id'],'甲',NOW)
plan_refresh.refresh(now=NOW)
after = pv.load(self.root)
self.assertEqual(after['main'][0]['verdict'],'仅展示')
self.assertNotIn('SH600003',[r['code'] for r in after['main']])
self.assertEqual(pv.load(self.root,DAY,morning=True),frozen)
if __name__ == '__main__':
unittest.main()