235 lines
13 KiB
Python
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()
|