akg-factor-bridge/test_plan_versions.py

246 lines
12 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""本地离线:python -m unittest test_plan_versions;全部来源用合成输入与替身。"""
import copy
import datetime as dt
import json
from pathlib import Path
import tempfile
import unittest
import sys
import types
from contextlib import ExitStack
from unittest.mock import patch
import pandas as pd
for name in ('psycopg', 'pymysql'):
try:
__import__(name)
except ImportError:
sys.modules[name] = types.ModuleType(name)
import plan
import plan_inputs as pi
import plan_versions as pv
import sources
DAY = '2026-10-14'
CUT = '2026-10-15T07:10:00+08:00'
def sample():
return {'date': DAY, 'plan_version': 'test', 'main': [
{'code': 'SH600001', 'rank': 1, 'rank_axis': 'quality', 'quality_band': 3,
'company_review': {'overall': '好', 'review_ref': 'a', 'period_fi': '2026Q2'}},
{'code': 'SH600002', 'rank': 2, 'rank_axis': 'quality'}],
'observe': [], 'candidates': [], 'watch': []}
class VersionsTest(unittest.TestCase):
def test_revision_window_and_no_replacement_morning(self):
import plan_refresh as refresh
calendar = types.ModuleType('chinese_calendar')
calendar.is_holiday = lambda day: day == dt.date(2026, 10, 1)
with patch.dict(sys.modules, {'chinese_calendar': calendar}):
for clock, expected in [('07:19:59', False), ('07:20:00', True), ('15:10:00', True), ('15:10:01', False)]:
self.assertEqual(refresh.in_window(dt.datetime.fromisoformat('2026-10-15T' + clock + '+08:00')), expected)
self.assertFalse(refresh.in_window(dt.datetime.fromisoformat('2026-10-01T09:00:00+08:00')))
self.assertFalse(refresh.in_window(dt.datetime.fromisoformat('2026-10-17T09:00:00+08:00')))
with patch.object(refresh.config, 'PLAN_SNAPSHOT_DIR', self.root):
self.assertEqual(refresh.refresh(now=dt.datetime.fromisoformat('2026-10-15T09:00:00+08:00'))['status'], 'no_morning')
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.root = self.tmp.name
def publish(self, p=None, inputs=None, params=None):
with pv.writer(self.root):
return pv.publish(self.root, p or sample(), inputs or {'x': 1}, params or {},
cutoff_at=CUT, reason='测试')
def test_append_idempotent_and_return_to_previous_inputs(self):
a = self.publish()
self.assertEqual(a, self.publish())
b = self.publish(inputs={'x': 2})
c = self.publish()
self.assertEqual(c['decision']['parent_id'], b['decision']['id'])
self.assertNotEqual(c['decision']['id'], a['decision']['id'])
self.assertEqual(pv.load(self.root, DAY, morning=True), a)
self.assertEqual(pv.load(self.root, decision_id=a['decision']['id']), a)
def test_failed_pointer_keeps_complete_previous_version(self):
a = self.publish()
real = pv.atomic
def fail(path, value):
if Path(path).name == 'plan_' + DAY + '.json':
raise OSError('模拟断电')
return real(path, value)
with patch.object(pv, 'atomic', fail), self.assertRaises(OSError):
self.publish(inputs={'x': 2})
self.assertEqual(pv.load(self.root, DAY), a)
orphans = [p.stem for p in (Path(self.root) / 'versions' / DAY).glob(DAY + '_*.json')
if p.stem != a['decision']['id']]
with self.assertRaises(FileNotFoundError):
pv.load(self.root, decision_id=orphans[0])
recovered = self.publish(inputs={'x': 2})
self.assertEqual(recovered['decision']['parent_id'], a['decision']['id'])
def test_first_morning_pointer_recovers_after_interruption(self):
real = pv.atomic
def fail(path, value):
if Path(path).name == 'morning.json':
raise OSError('晨版指针中断')
return real(path, value)
with patch.object(pv, 'atomic', fail), self.assertRaises(OSError):
self.publish()
first = pv.load(self.root, DAY)
self.assertEqual(pv.load(self.root, DAY, morning=True), first)
self.publish(inputs={'x': 2})
self.assertEqual(pv.load(self.root, DAY, morning=True), first)
def test_parallel_duplicate_publish_has_one_version(self):
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(4) as pool:
values = list(pool.map(lambda _: self.publish(), range(8)))
self.assertEqual(len({p['decision']['id'] for p in values}), 1)
self.assertEqual(len(pv.history(self.root, DAY)), 1)
def test_health_exposes_stopped_refresh_and_corrupt_pointer(self):
import plan_health
import plan_refresh
self.publish()
pv.atomic(Path(self.root) / 'versions' / DAY / 'health.json', {'checked_at': CUT})
with patch.object(plan_refresh, 'in_window', return_value=True):
status, reading = plan_health.inspect(self.root, dt.datetime.fromisoformat('2026-10-15T08:00:00+08:00'))
self.assertEqual(status, 1)
self.assertIn('十二分钟', reading['error'])
bad = pv.load(self.root, DAY)
bad['main'][0]['score'] = 999
pv.atomic(Path(self.root) / ('plan_' + DAY + '.json'), bad)
self.assertEqual(plan_health.inspect(self.root)[0], 2)
def test_full_rank_does_not_follow_query_clipping(self):
self.publish()
with patch.object(plan.config, 'PLAN_SNAPSHOT_DIR', self.root):
small = plan.from_snapshot(DAY, top=1)
big = plan.from_snapshot(DAY, top=20)
self.assertEqual(small['main'][0]['research_rank'], big['main'][0]['research_rank'])
self.assertEqual(big['main'][1]['research_rank'], 2)
def test_changed_review_all_exports_share_research(self):
a = self.publish()
p = sample()
p['main'][0]['company_review'].update(overall='差', review_ref='b')
p['candidates'] = [p['main'][0]]
b = self.publish(p, {'x': 2})
self.assertEqual(b['main'][0]['research'], b['candidates'][0]['research'])
self.assertEqual(b['main'][0]['research']['changes'][0]['field'], 'overall')
self.assertEqual(pv.load(self.root, decision_id=a['decision']['id'])['main'][0]['company_review']['overall'], '好')
def test_config_change_publishes_and_path_is_validated(self):
a = self.publish()
self.assertNotEqual(self.publish(params={'cap': 5})['decision']['id'], a['decision']['id'])
with self.assertRaises(ValueError):
pv.load(self.root, decision_id='../../config')
def test_capture_replay_typed_inputs_and_fail_closed(self):
frame = pd.DataFrame({'code': ['A', 'B'], 'score': [1., float('nan')],
'date': pd.to_datetime(['2026-10-14', None])})
b = pi.Bundle(params={'CAP': 5})
with b.use():
first = pi.read('prices', lambda: frame)
recorded = json.loads(json.dumps(b.records))
with pi.Bundle(records=recorded).use():
again = pi.read('prices', lambda: self.fail('重放不得回源'))
pd.testing.assert_frame_equal(first, again)
with self.assertRaises(RuntimeError):
with pi.Bundle(records=recorded).use():
try:
pi.read('new-source', lambda: None)
except RuntimeError:
pass # 上层吞错也不能发布不完整输入。
def test_future_review_never_leaks_but_morning_can_use_known_review(self):
def reader(sql, params):
self.assertIn('ran_at <=', sql)
return pd.DataFrame([{'ts_code': '600001.SH', 'period': '2026Q2',
'summary': {'overall': '好'}, 'grades': {}, 'ran_at': '2026-10-15T06:50:00+08:00'}])
self.assertEqual(sources.company_reviews(['SH600001'], DAY, read_pg=reader), {})
self.assertEqual(sources.company_reviews(['SH600001'], DAY, read_pg=reader,
cutoff_at=CUT)['SH600001']['overall'], '好')
def test_source_failure_does_not_mean_no_review(self):
with self.assertRaises(OSError):
sources.company_reviews(['SH600001'], DAY, strict=True,
read_pg=lambda *a: (_ for _ in ()).throw(OSError('offline')))
def test_complete_revision_replays_real_assembly_without_other_sources(self):
import config
import factors
import judgement
import logic_state_daily
import plan_refresh
codes = ['SH600001', 'SH600002']
reviews = {c: {'overall': '好', 'doubt_hard': False, 'age_days': 0,
'ran_at': DAY, 'review_ref': 'first'} for c in codes}
with ExitStack() as stack:
def patcher(obj, name, **kw): return stack.enter_context(patch.object(obj, name, **kw))
patcher(config, 'PLAN_SNAPSHOT_DIR', new=self.root)
patcher(config, 'PLAN_RANK_AXIS', new='quality')
patcher(config, 'CARD_COMPANY_QUALITY_GATE', new=True)
patcher(config, 'LOGIC_PATH_COMPANY', new=True)
patcher(plan, '_factor', side_effect=lambda table, day: pd.Series(
[240., 230.] if 'score' in table else [0.3, 0.2] if 'upside' in table else [2., 2.], index=codes))
patcher(plan, '_latest_date', return_value=DAY)
patcher(plan, '_prev_date', return_value=None)
patcher(plan, '_names', return_value=dict(zip(codes, ['甲', '乙'])))
patcher(plan, '_evidence', return_value=({c: ('材料', 3, .1, 10, 1) for c in codes}, {DAY}))
patcher(plan, '_segments_of', return_value={})
patcher(factors, '_risk_set', return_value=set())
patcher(judgement, 'load_previous', return_value=[])
patcher(judgement, 'recent_rows', return_value={})
patcher(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'):
patcher(sources, name, return_value={})
patcher(sources, 'stock_daily', return_value={c: {'pct0': 3} for c in codes})
patcher(sources, 'night_conclusions', return_value={c: {'accum_state': '明确吸筹', 'accum_age': 0} for c in codes})
source = patcher(sources, 'company_reviews', side_effect=lambda *a, **kw: copy.deepcopy(reviews))
b = pi.Bundle(params=pi.effective_config(config), cutoff_at=CUT)
with b.use():
data = plan.collect(DAY)
data.update(data.pop('_full'))
inputs = {'records': b.records, 'market': {}, 'regime': None}
with pv.writer(self.root):
a = pv.publish(self.root, data, inputs, b.params, cutoff_at=CUT, reason='晨版')
first = copy.deepcopy(a)
reviews[codes[0]].update(overall='差', doubt_hard=True, review_ref='second')
patcher(plan_refresh, 'in_window', return_value=True)
result = plan_refresh.refresh(now=dt.datetime.fromisoformat('2026-10-15T09:00:00+08:00'))
self.assertEqual(result['status'], 'published')
revised = pv.load(self.root, DAY)
bycode = {r['code']: r for r in revised['main']}
self.assertEqual(revised['main'][0]['code'], codes[1])
self.assertEqual(bycode[codes[0]]['company_review']['overall'], '差')
self.assertNotEqual(bycode[codes[0]]['quality_band'], first['main'][0]['quality_band'])
self.assertNotEqual(bycode[codes[0]]['verdict'], first['main'][0]['verdict'])
self.assertEqual(pv.load(self.root, decision_id=first['decision']['id']), first)
source.side_effect = OSError('上游不可达')
with self.assertRaises(OSError):
plan_refresh.refresh(now=dt.datetime.fromisoformat('2026-10-15T09:05:00+08:00'))
self.assertEqual(pv.load(self.root, DAY), revised)
self.assertEqual(pv.health(self.root, DAY)['pending_codes'], codes)
def test_evidence_ties_independent_of_database_row_order(self):
rows = [{'ts_code': '600001.SH', 'target': target, 'n_sources': 2,
'moved_ratio': .5, 'members_total': 10, 'moved': 5, 'mkt_trade_date': DAY}
for target in ('甲', '乙')]
with patch.object(plan.db, 'read_pg', return_value=pd.DataFrame(rows)):
first = plan._evidence(DAY)
with patch.object(plan.db, 'read_pg', return_value=pd.DataFrame(rows[::-1])):
self.assertEqual(plan._evidence(DAY), first)
if __name__ == '__main__':
unittest.main()