305 lines
16 KiB
Python
305 lines
16 KiB
Python
"""本地离线: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_generate_reuses_legacy_and_complete_without_sources(self):
|
||
for complete in (False, True):
|
||
with tempfile.TemporaryDirectory() as root:
|
||
if complete:
|
||
with pv.writer(root):
|
||
pv.publish(root, sample(), {'x': 1}, {}, cutoff_at=CUT, reason='晨版')
|
||
else:
|
||
pv.atomic(Path(root) / ('plan_' + DAY + '.json'), sample())
|
||
files = {p: p.read_bytes() for p in Path(root).rglob('*.json')}
|
||
with patch.object(plan.config, 'PLAN_SNAPSHOT_DIR', root), \
|
||
patch.object(plan, 'collect', side_effect=AssertionError('禁止重采集')), \
|
||
patch.object(plan, 'write_published_md'):
|
||
self.assertTrue(plan.generate(DAY).endswith('plan_' + DAY + '.md'))
|
||
self.assertEqual(files, {p: p.read_bytes() for p in Path(root).rglob('*.json')})
|
||
|
||
def test_publish_cannot_replace_legacy_bytes(self):
|
||
path = Path(self.root) / ('plan_' + DAY + '.json')
|
||
path.write_text(json.dumps(sample(), indent=4))
|
||
original = path.read_bytes()
|
||
with self.assertRaisesRegex(ValueError, '旧格式计划只读'):
|
||
self.publish(inputs={'new': 'research'})
|
||
self.assertEqual(path.read_bytes(), original)
|
||
self.assertFalse((Path(self.root) / 'versions').exists())
|
||
|
||
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_intraday_recovery_is_queryable_but_not_morning_history(self):
|
||
with pv.writer(self.root):
|
||
result = pv.publish(self.root, sample(), {'x': 1}, {},
|
||
cutoff_at='2026-10-15T10:00:00+08:00', reason='晨版生成')
|
||
self.assertEqual(result['decision']['publication_kind'], 'recovery')
|
||
self.assertEqual(result['decision']['reason'], '数据恢复后补发')
|
||
self.assertFalse(pv.morning_eligible(result))
|
||
self.assertEqual(pv.load(self.root, decision_id=result['decision']['id']), result)
|
||
self.assertEqual(pv.load(self.root, DAY, morning=True), result)
|
||
early = copy.deepcopy(result)
|
||
early['decision']['cutoff_at'] = '2026-10-15T09:29:59+08:00'
|
||
self.assertTrue(pv.morning_eligible(early))
|
||
early['decision']['cutoff_at'] = '2026-10-15T09:30:00+08:00'
|
||
self.assertFalse(pv.morning_eligible(early))
|
||
|
||
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_latest_legacy_survives_code_deployment_without_reassembly(self):
|
||
import version
|
||
legacy = sample()
|
||
legacy.update(plan_version='old-code', generated_at=(
|
||
dt.datetime.now(dt.timezone.utc) - dt.timedelta(hours=2)).isoformat())
|
||
path = Path(self.root) / ('plan_' + DAY + '.json')
|
||
path.write_text(json.dumps(legacy), encoding='utf-8')
|
||
original = path.read_bytes()
|
||
with patch.object(plan.config, 'PLAN_SNAPSHOT_DIR', self.root), \
|
||
patch.object(version, 'git_short_rev', return_value='new-code'), \
|
||
patch.object(plan, 'collect', side_effect=AssertionError('查询禁止重装配')), \
|
||
patch.object(plan.db, 'read_pg', side_effect=AssertionError('查询禁止回源')):
|
||
latest = plan.from_snapshot(top=1)
|
||
dated = plan.from_snapshot(DAY, top=1)
|
||
self.assertEqual(latest, dated)
|
||
self.assertEqual(latest['plan_version'], 'old-code')
|
||
self.assertEqual(latest['traceability'], 'legacy_unverified')
|
||
self.assertIsNone(latest.get('decision'))
|
||
self.assertEqual(path.read_bytes(), original)
|
||
|
||
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()
|