akg-factor-bridge/test_user_research.py

245 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.

"""人工关注评析:所有外部来源与投递均用桩,状态文件仅在临时目录。"""
import copy
import datetime as dt
import io
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
import urllib.error
import urllib.parse
import test_plan_versions # 缺席数据库驱动用桩;统一由断网护栏启动。
import config
import sources
import user_candidates as uc
import user_research as ur
import plan_versions as pv
import review_targets as rt
NOW = dt.datetime.fromisoformat('2026-11-04T10:00:00+08:00')
CODE = 'SZ300133'
def report(**changes):
return dict({'review_ref': 'a' * 64, 'brain_used': True, 'brain_status': 'ok',
'thesis': '订单改善仍需后续验证', 'overall': '中',
'report_ran_at': '2026-11-03T18:00:00+00:00',
'checked_at': '2026-11-03T18:00:00+00:00'}, **changes)
class ResearchTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = self.temp.name
self.reader = Mock(return_value={})
self.submit = Mock(return_value={'status': 'queued', 'task_id': 'private-task'})
self.patches = [patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root),
patch.object(config, 'USER_RESEARCH_FRESH_DAYS', 7),
patch.object(config, 'USER_RESEARCH_SUBMIT_LIMIT', 3)]
for p in self.patches:
p.start()
self.addCleanup(p.stop)
uc.save(self.root, {'codes': [CODE], 'reason': '自主关注', 'expires_on': '2026-11-10'}, 'test', NOW)
def sync(self, **kwargs):
return ur.sync(self.root, now=kwargs.pop('now', NOW), reader=self.reader,
submit=self.submit, target_write=lambda *a: None, **kwargs)
def test_complete_requires_real_reference_brain_thesis_and_time(self):
self.assertTrue(ur.report_state(report(), NOW)[0])
for change in ({'review_ref': None}, {'review_ref': 'old'}, {'brain_used': False},
{'brain_status': 'half'}, {'thesis': ''}, {'report_ran_at': None},
{'report_ran_at': '2026-11-05T10:00:00+08:00'}):
with self.subTest(change=change):
self.assertFalse(ur.report_state(report(**change), NOW)[0])
def test_recent_real_recheck_keeps_old_report_ready_without_redating(self):
old = report(report_ran_at='2026-09-29T00:00:00+00:00')
self.reader.return_value = {CODE: old}
self.sync()
self.submit.assert_not_called()
view = ur.views(self.root, [CODE], now=NOW, reader=self.reader)[CODE]
self.assertEqual(view['review_status'], 'completed')
self.assertEqual(view['review_data_date'], '2026-09-29')
self.assertNotIn('task_id', view)
def test_future_check_cannot_freshen_stale_report(self):
old = report(report_ran_at='2026-09-29T00:00:00+00:00', checked_at='2026-11-05T00:00:00+00:00')
self.assertFalse(ur.report_state(old, NOW)[0])
def test_claim_is_durable_before_submission_and_prevents_double_enqueue(self):
def submit(code):
self.assertEqual(ur.read(self.root)['rows'][code]['status'], 'pending')
self.sync() # 并发调用能看到已持久化的 claim,不能再次派单。
return {'status': 'queued', 'task_id': 'private-task'}
self.submit.side_effect = submit
self.sync()
self.sync()
self.assertEqual(self.submit.call_count, 1)
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'queued')
self.assertEqual(row['task_id'], 'private-task')
def test_timeout_is_uncertain_not_failure_or_automatic_retry(self):
self.submit.side_effect = TimeoutError('offline timeout')
self.sync()
self.sync(now=NOW + dt.timedelta(hours=2))
self.assertEqual(self.submit.call_count, 1)
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'pending')
self.assertIn('待核实', row['error'])
def test_completed_report_recovers_queued_or_uncertain_request(self):
self.sync()
self.reader.return_value = {CODE: report()}
self.sync(now=NOW + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
self.assertEqual(self.submit.call_count, 1)
def test_submission_done_is_not_report_completion(self):
self.submit.return_value = {'status': 'done', 'result': {'status': 'ok'}}
self.sync()
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'pending')
self.reader.return_value = {CODE: report()}
self.sync(now=NOW + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
def test_old_no_reference_recheck_is_failed_not_fabricated_completed(self):
self.reader.return_value = {CODE: report(review_ref=None)}
self.sync()
self.reader.return_value = {CODE: report(review_ref=None, checked_at='2026-11-04T10:01:00+08:00')}
self.sync(now=NOW + dt.timedelta(minutes=5))
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'failed')
self.assertIn('固定版本', row['error'])
self.assertEqual(self.submit.call_count, 1)
def test_explicit_rejection_does_not_retry_every_schedule(self):
self.submit.side_effect = urllib.error.HTTPError('offline', 403, '', {}, None)
self.sync()
self.sync()
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'failed')
self.assertEqual(self.submit.call_count, 1)
def test_source_failure_never_submits_and_get_reports_failure(self):
self.reader.side_effect = RuntimeError('offline unavailable')
self.assertEqual(self.sync()['status'], 'failed')
self.submit.assert_not_called()
self.assertEqual(ur.views(self.root, [CODE], now=NOW, reader=self.reader)[CODE]['review_status'], 'failed')
def test_readonly_listing_reads_live_reports_without_side_effects(self):
before = {p.name: p.read_bytes() for p in Path(self.root).iterdir() if p.is_file()}
with patch.object(ur, 'load_reports', return_value={CODE: report()}), \
patch.object(ur, 'submit_review', side_effect=AssertionError('GET不可投递')):
row = uc.listing(self.root, NOW)['rows'][0]
self.assertEqual(row['status'], 'pending') # 尚无计划仍可有真实完成报告。
self.assertEqual(row['review_status'], 'completed')
self.assertEqual(row['review_ref'], 'a' * 64)
self.assertEqual(before, {p.name: p.read_bytes() for p in Path(self.root).iterdir() if p.is_file()})
def test_removed_expired_and_out_of_scope_never_submit(self):
uc.remove(self.root, uc.active(self.root, NOW)[0]['id'], 'test', NOW)
self.sync()
self.submit.assert_not_called()
state = uc.read(self.root)
state['rows'].append({'id': 'bad', 'code': 'BJ920001', 'expires_on': '2026-11-10'})
pv.atomic(Path(self.root) / 'user_candidates.json', state)
self.sync()
self.submit.assert_not_called()
self.assertEqual(ur.views(self.root, ['920001.BJ'], now=NOW, reader=self.reader), {})
def test_bounded_submissions_continue_next_natural_cycle(self):
uc.save(self.root, {'codes': ['300364', '300182', '603533', '300291', '301052'],
'reason': '自主关注', 'expires_on': '2026-11-10'}, 'test', NOW)
self.assertEqual(self.sync()['submitted'], 3)
self.assertEqual(self.sync()['submitted'], 3)
self.assertEqual(self.sync()['submitted'], 0)
self.assertEqual(self.submit.call_count, 6)
def test_stale_complete_gets_real_recheck_then_checked_at_recovers(self):
self.reader.return_value = {CODE: report()}
self.sync()
later = NOW + dt.timedelta(days=8)
# 延长关注仅供隔离测试,不改变报告时间。
state = uc.read(self.root)
state['rows'][0]['expires_on'] = '2026-11-30'
pv.atomic(Path(self.root) / 'user_candidates.json', state)
self.assertEqual(self.sync(now=later)['submitted'], 1)
self.reader.return_value = {CODE: report(checked_at=later.isoformat())}
self.sync(now=later + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
def test_targets_append_all_manual_without_score_verdict_or_prefix_cut(self):
snap = {'main': [{'code': f'SH60{i:04d}', 'score': 300-i, 'rank': i+1} for i in range(150)],
'observe': [], 'user_candidates': [dict(r, verdict='仅展示', score=None) for r in uc.active(self.root, NOW)]}
got = []
rt.persist('2026-11-03', snap, write=lambda day, rows: got.extend(rows))
row = next(r for r in got if r['ts_code'] == '300133.SZ')
self.assertEqual(row['source'], 'manual')
self.assertEqual(len(got), rt.TOP_MAIN + 1)
rows = rt.build_rows('2026-11-03', [], [], [{'code': 'BJ920001'}, {'code': CODE}, {'code': CODE}])
self.assertEqual([r['ts_code'] for r in rows], ['300133.SZ'])
def test_target_sync_preserves_plan_files_and_removes_deleted_manual_rows(self):
snap = {'date': '2026-11-03', 'main': [], 'observe': [], 'decision': {'id': 'read-only'}}
path = Path(self.root) / 'plan_2026-11-03.json'
pv.atomic(path, snap)
before = path.read_bytes()
got = []
ur.sync(self.root, now=NOW, reader=self.reader, submit=self.submit,
target_write=lambda day, rows: got.append(rows))
self.assertEqual(got[-1][0]['ts_code'], '300133.SZ')
self.assertEqual(path.read_bytes(), before)
uc.remove(self.root, uc.active(self.root, NOW)[0]['id'], 'test', NOW)
ur.sync(self.root, now=NOW, reader=self.reader, submit=self.submit,
target_write=lambda day, rows: got.append(rows))
self.assertEqual(got[-1], [])
self.assertEqual(path.read_bytes(), before)
def test_submit_uses_fixed_base_and_flags_without_redirect(self):
response = io.BytesIO(json.dumps({'status': 'queued', 'task_id': 'x'}).encode())
opener = Mock()
opener.open.return_value = response
with patch.object(config, 'AKG_API_BASE', 'http://offline.invalid:8000'), \
patch.object(ur.urllib.request, 'build_opener', return_value=opener):
self.assertEqual(ur.submit_review(CODE)['status'], 'queued')
req = opener.open.call_args.args[0]
url = urllib.parse.urlsplit(req.full_url)
self.assertEqual((url.netloc, url.path), ('offline.invalid:8000', '/admin/company_review'))
self.assertEqual(req.method, 'POST')
q = urllib.parse.parse_qs(url.query)
self.assertEqual(q, {'ts_code': ['300133.SZ'], 'force': ['false'], 'sync': ['false'],
'with_brain': ['true'], 'with_qual': ['true']})
self.assertLessEqual(opener.open.call_args.kwargs['timeout'], 10)
with self.assertRaises(urllib.error.HTTPError):
ur._NoRedirect().redirect_request(req, None, 302, '', {}, 'http://elsewhere.invalid')
def test_checked_column_only_for_live_independent_research(self):
import pandas as pd
row = {'ts_code': '300133.SZ', 'period': '2026Q3', 'review_version': 'v',
'grades': {}, 'summary': report(), 'brain_used': True, 'brain_status': 'ok',
'ran_at': dt.datetime.fromisoformat('2026-09-29T00:00:00+00:00'),
'checked_at': NOW}
reader = Mock(return_value=pd.DataFrame([row]))
got = sources.company_reviews([CODE], '2026-11-04', read_pg=reader,
cutoff_at=NOW.isoformat(), include_check=True)
self.assertIn('checked_at', reader.call_args.args[0])
self.assertEqual(got[CODE]['checked_at'], NOW.isoformat())
normal = sources.company_reviews([CODE], '2026-11-04', read_pg=reader, cutoff_at=NOW.isoformat())
self.assertNotIn('checked_at', normal[CODE])
self.assertNotIn(', checked_at', reader.call_args.args[0])
def test_background_research_failure_does_not_block_plan_refresh(self):
import plan_refresh
with patch.object(ur, 'sync', side_effect=RuntimeError('offline failure')), \
patch.object(plan_refresh, 'refresh', return_value={'status': 'unchanged'}) as refresh:
self.assertEqual(uc.refresh_saved()['status'], 'unchanged')
refresh.assert_called_once()
if __name__ == '__main__':
unittest.main()