tradingSystem/scripts/test_monitor_watch_units.py

235 lines
13 KiB
Python

"""人工关注观察发布与回执隔离,不接交易链、不联网。"""
import unit_test_guard
import copy
import json
import unittest
from datetime import datetime, timedelta
from unittest.mock import Mock, patch
from test_wiring import install_fakes
from app.services import monitor_watch as mw, plan_candidates as pc
NOW = datetime.fromisoformat('2026-11-04T10:30:00+08:00')
CODE = '300133.SZ'
REQUEST = pc.request
def row(**changes):
return dict({'id': 'a'*32, 'code': 'SZ300133', 'name': '示例人工关注',
'status': 'evaluated', 'expires_on': '2026-11-24', 'review_status': 'completed',
'review_updated_at': '2026-11-04T09:10:00+08:00', 'review_data_date': '2026-11-04',
'review_ref': 'b'*64, 'company_review': {'overall': '质量待观察', 'report_ran_at': '2026-11-04T09:10:00+08:00'},
'company_review_text': '真实报告摘要'}, **changes)
def registry(rows=None, revision=3):
return {'ok': True, 'revision': revision, 'rows': [row()] if rows is None else rows, 'writable': True}
class MonitorWatchTests(unittest.TestCase):
def setUp(self):
install_fakes(params={'PMS_MONITOR_WATCH_SCOPE': mw.SCOPE,
'PMS_MONITOR_WATCH_TTL_SEC': 600, 'PMS_PLAN_API_BASE': 'http://plan.test'})
self.client = Mock()
self.client.eval.return_value = 1
self.client.get.return_value = None
self.reader = patch.object(pc, 'request', return_value=registry()).start()
patch.object(mw.signal_service, '_client', return_value=self.client).start()
self.clock = patch.object(mw, '_now', side_effect=lambda now=None: now or NOW).start()
self.addCleanup(patch.stopall)
def receipt(self, **changes):
published = mw.build_snapshot(registry(), now=NOW)
report = {'schema_version': 1, 'source_scope': mw.SCOPE, 'items': {CODE: {
'watch_id': 'a'*32, 'watch_revision': 3, 'review_ref': 'b'*64,
'daily': {'state': 'COMPLETE', 'analysis_date': '2026-11-04', 'data_date': '2026-11-03'},
'intraday': {'state': 'QUEUED', 'deadline_at': '2026-11-04T10:35:00+08:00'}}}}
report['items'][CODE].update(changes)
self.client.get.side_effect = lambda key: json.dumps(published if key.startswith(mw.SOURCE_KEY) else report)
return published, report
def test_only_completed_review_enters_independent_scope(self):
data = registry([row(verdict='仅展示', last_analysis_signal='DROPPED'),
row(id='c'*32, code='SZ300364', review_status='queued'),
row(id='d'*32, code='SZ300182', review_status='missing')])
result = mw.build_snapshot(data, now=NOW)
self.assertEqual([x['ts_code'] for x in result['items']], [CODE])
self.assertEqual(result['items'][0]['review_status'], 'ready')
self.assertNotIn('verdict', result['items'][0])
self.assertEqual(result['expires_at'], '2026-11-04T10:40:00+08:00')
def test_expired_removed_and_other_exchange_never_published(self):
rows = [row(expires_on='2026-11-03'), row(removed_at='2026-11-04T10:00:00+08:00'),
row(status='removed'), row(code='BJ920001'), row(code='SH510300')]
self.assertEqual(mw.build_snapshot(registry(rows), now=NOW)['items'], [])
self.assertTrue(mw.active(row(expires_on='2026-11-04'), NOW))
def test_completed_requires_actual_report_metadata(self):
for changes in ({'review_ref': ''}, {'company_review': None}, {'review_data_date': '2026-11-03'},
{'company_review': {'overall':'好', 'report_ran_at': '2026-11-04T09:10:00'}},
{'company_review': {'overall':'好', 'report_ran_at': '2026-11-04T11:00:00+08:00'}}):
with self.subTest(changes=changes), self.assertRaises(ValueError):
mw.build_snapshot(registry([row(**changes)]), now=NOW)
def test_evaluated_is_not_review_completed(self):
r = row(); r.pop('review_status')
self.assertEqual(mw.build_snapshot(registry([r]), now=NOW)['items'], [])
def test_alert_scope_includes_active_without_review_without_expanding_research(self):
result = mw.build_snapshot(registry([row(review_status='missing'),
row(code='SZ300182', id='c'*32, review_status='queued'),
row(code='SZ300364', status='removed'), row(code='BJ920001'),
row(code='SZ300291', expires_on='2026-11-03')]), now=NOW)
self.assertEqual(result['items'], [])
self.assertEqual([r['ts_code'] for r in result['alert_items']], ['300133.SZ','300182.SZ'])
self.assertNotIn('review_summary', result['alert_items'][0])
def test_default_scope_disabled_makes_no_external_request(self):
install_fakes(params={})
self.assertEqual(mw.sync(), {'ok': True, 'skipped': 'disabled'})
self.reader.assert_not_called(); self.client.eval.assert_not_called()
def test_removed_last_stock_publishes_authoritative_empty(self):
self.reader.return_value = registry([], revision=4)
result = mw.sync()
self.assertTrue(result['ok']); self.assertEqual(result['returned'], 0)
args = self.client.eval.call_args.args
self.assertEqual(args[2], mw.SOURCE_KEY+mw.SCOPE)
payload = json.loads(args[3])
self.assertEqual(payload['items'], []); self.assertEqual(payload['source_revision'], 4)
self.assertEqual(args[4], 600)
def test_registry_failure_preserves_prior_snapshot(self):
self.reader.side_effect = ValueError('读取失败')
self.assertFalse(mw.sync()['ok']); self.client.eval.assert_not_called()
def test_incomplete_registry_not_forged_as_empty(self):
self.reader.return_value = {'ok': True, 'rows': []}
self.assertFalse(mw.sync()['ok']); self.client.eval.assert_not_called()
def test_redis_rejects_older_publication_and_failure_is_visible(self):
self.client.eval.return_value = 0
self.assertFalse(mw.sync()['ok'])
self.client.eval.side_effect = RuntimeError('断开')
self.assertFalse(mw.sync()['ok'])
def test_receipt_preserves_real_dates_and_does_not_promote_queue(self):
self.receipt()
result, note = mw.coverage(registry(), now=NOW)
self.assertEqual(note, '')
self.assertEqual(result[CODE]['daily']['data_date'], '2026-11-03')
self.assertEqual(result[CODE]['intraday']['state'], 'QUEUED')
def test_old_review_or_registry_receipt_is_not_current_coverage(self):
self.receipt(watch_id='c'*32)
self.assertEqual(mw.coverage(registry(), now=NOW)[0], {})
self.receipt(review_ref='c'*64)
self.assertEqual(mw.coverage(registry(), now=NOW)[0], {})
self.receipt(watch_revision=2)
self.assertEqual(mw.coverage(registry(), now=NOW)[0], {})
self.receipt()
self.assertEqual(mw.coverage(registry(revision=4), now=NOW)[0], {})
def test_expired_snapshot_removed_watch_and_read_failure_not_covered(self):
published, _ = self.receipt()
published['expires_at'] = NOW.isoformat()
self.assertEqual(mw.coverage(registry(), now=NOW)[0], {})
self.receipt()
self.assertEqual(mw.coverage(registry([row(status='removed')]), now=NOW)[0], {})
self.client.get.side_effect = RuntimeError('断开')
result, note = mw.coverage(registry(), now=NOW)
self.assertEqual(result, {}); self.assertIn('暂不可用', note)
def test_listing_keeps_watch_outside_plan_and_historical_dropped(self):
from app.repo import downstream_repo
with patch.object(downstream_repo, 'fetch_nightly_verdicts', return_value={CODE: {'verdict':'DROPPED','trade_date':20260910}}):
result = mw.listing()
self.assertTrue(result['rows'][0]['active'])
self.assertEqual(result['rows'][0]['last_analysis_signal'], 'DROPPED')
self.assertEqual(result['rows'][0]['last_analysis_date'], 20260910)
self.client.eval.assert_not_called()
def test_listing_read_failure_does_not_erase_registration(self):
from app.repo import downstream_repo
with patch.object(downstream_repo, 'fetch_nightly_verdicts', side_effect=ValueError('缺数据')):
result = mw.listing()
self.assertEqual(len(result['rows']),1)
self.assertIsNone(result['rows'][0]['last_analysis_date'])
self.assertIn('暂不可用', result['rows'][0]['last_analysis_error'])
def test_get_route_never_dispatches_or_publishes(self):
from app.web import main
with patch.object(mw, 'sync') as sync:
result = main.api_user_candidates()
self.assertTrue(result['ok']); sync.assert_not_called(); self.client.eval.assert_not_called()
def test_periodic_sync_works_during_execution_halt_and_nontrading_day(self):
from app import scheduler
with patch.object(scheduler.td, 'is_trade_day', return_value=False), patch.object(mw, 'sync', return_value={'ok':True}) as sync:
result = scheduler.monitor_watch_sync()
self.assertTrue(result['ok']); sync.assert_called_once()
self.assertIn('monitor_watch_sync', scheduler.celery_app.conf.beat_schedule)
def test_manual_research_is_read_only_and_requires_active_completed(self):
# 观察发布开关关闭不撤销用户查看已有报告的权利。
install_fakes(params={})
self.assertEqual(mw.research_row(CODE)['review_ref'], 'b'*64)
self.reader.return_value = registry([row(review_status='queued')])
self.assertIsNone(mw.research_row(CODE))
self.client.eval.assert_not_called()
def test_source_config_and_ttl_validation(self):
self.assertIsNone(mw.param_store._range_check('PMS_MONITOR_WATCH_SCOPE', mw.SCOPE))
self.assertTrue(mw.param_store._range_check('PMS_MONITOR_WATCH_SCOPE', 'pms-real-188'))
self.assertTrue(mw.param_store._range_check('PMS_MONITOR_WATCH_TTL_SEC', 601))
self.assertEqual(mw.param_store.FAIL_CLOSED['PMS_MONITOR_WATCH_SCOPE'], '')
def test_mutation_refresh_failure_is_reported_without_reversing_saved_registration(self):
import requests
from config.settings import settings
response = Mock(status_code=200); response.json.return_value = {'ok': True, 'added': 1}
with patch.object(settings, 'PMS_PLAN_WRITE_KEY', 'test'), patch.object(requests, 'request', return_value=response), \
patch.object(mw, 'sync', return_value={'ok': False, 'error': '等待同步'}) as sync:
result = REQUEST('POST', payload={'codes': [CODE]})
self.assertTrue(result['ok']); self.assertFalse(result['monitor_sync']['ok']); sync.assert_called_once()
def test_manual_research_and_report_are_available_without_trade_plan(self):
from app.web import main
from app.services import logic_state_service, plan_feed, company_report
r = row(company_review={'overall':'待观察','report_url':'https://report.test/company'})
self.reader.return_value = registry([r])
with patch.object(logic_state_service, 'state_map', return_value={}), patch.object(plan_feed, 'get_plan', return_value={'main': [], 'observe': []}):
result, src = main._research_st(CODE)
url, report_src = company_report.report_url_for(CODE)
self.assertEqual(src, 'watch'); self.assertEqual(result['company_review']['overall'], '待观察')
self.assertEqual(report_src, 'watch'); self.assertEqual(url, 'https://report.test/company')
self.client.eval.assert_not_called()
def test_review_recheck_time_does_not_replace_report_generation_time(self):
r = row(review_updated_at='2026-11-04T10:20:00+08:00', review_data_date='2026-11-03',
company_review={'overall':'质量待观察','report_ran_at':'2026-11-03T23:10:00+08:00'})
item = mw.build_snapshot(registry([r]), now=NOW)['items'][0]
self.assertEqual(item['review_completed_at'], '2026-11-03T23:10:00+08:00')
self.assertEqual(item['review_data_date'], '2026-11-03')
def test_waiting_receipt_past_deadline_is_expired_without_server_write(self):
self.receipt(intraday={'state':'QUEUED','deadline_at':NOW.isoformat()})
result, _ = mw.coverage(registry(), now=NOW)
self.assertEqual(result[CODE]['intraday']['state'], 'EXPIRED')
self.client.eval.assert_not_called()
def test_complete_observation_and_unavailable_reason_keep_actual_source_dates(self):
self.receipt(daily={'state':'COMPLETE','observation':'WATCH','reason':'日线仍在整理',
'data_date':'2026-11-03','completed_at':'2026-11-04T10:15:00+08:00'},
intraday={'state':'UNAVAILABLE','observation':None,'reason':'等待当日新鲜分钟行情'})
result, _ = mw.coverage(registry(), now=NOW)
self.assertEqual(result[CODE]['daily']['observation'], 'WATCH')
self.assertEqual(result[CODE]['daily']['data_date'], '2026-11-03')
self.assertEqual(result[CODE]['daily']['completed_at'], '2026-11-04T10:15:00+08:00')
self.assertIn('分钟行情', result[CODE]['intraday']['reason'])
self.client.eval.assert_not_called()
if __name__ == '__main__':
unittest.main()