tradingSystem/scripts/test_batch51_units.py

338 lines
20 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.

"""跨日复核:真实单表SQL事务、决策重走、委托回报与人工确认并发。"""
import unit_test_guard
import copy
import os, sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import json
import tempfile
import unittest
from datetime import datetime, timedelta
from unittest.mock import patch
from sqlalchemy import create_engine, text, event
from app.db import session
from app.repo import pms_repo, qmt_repo
from app.services import daily_buy_review as dr, proposal_service as ps, dispatcher, execution_conflicts, executor
NOW = datetime(2026, 10, 30, 10, 0)
CODE = '300693.SZ'
class DailyReviewTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory(); self.addCleanup(self.tmp.cleanup)
self.engine = create_engine('sqlite:///' + self.tmp.name + '/state.sqlite')
self.addCleanup(self.engine.dispose)
def register_json_functions(connection, _):
# 生产用 MariaDB;这里精确补齐仓储所用的单个顶层路径存在性语义。
# 键存在且值为 null 仍返回 1,不能用 value is not None 代替。
def contains_path(document, mode, path):
if document is None or mode is None or path is None:
return None
if mode != 'one' or not path.startswith('$.') or '.' in path[2:] or '[' in path:
raise ValueError('测试 JSON_CONTAINS_PATH 不支持该路径形状')
value = json.loads(document)
return int(isinstance(value, dict) and path[2:] in value)
connection.create_function('JSON_CONTAINS_PATH', 3, contains_path)
event.listen(self.engine, 'connect', register_json_functions)
self.use(session, 'get_engine', return_value=self.engine)
self.use(session, '_check_cooldown')
self.params = {'PMS_DAILY_BUY_REVIEW': True}
self.use(dr.param_store, 'get_bool', side_effect=lambda k, d=False: self.params.get(k, d))
self.orders = []
self.use(qmt_repo, 'orders_for_parent', side_effect=lambda _: copy.deepcopy(self.orders))
self.cancel = self.use(dispatcher, 'cancel', return_value={'ok': True})
self.fresh = {'candidate': {'ts_code': CODE, 'action': 'OPEN', 'side': 'buy', 'qty': 400,
'hard_numbers': {'plan_basis': {'research': 'today'}, 'scan_params_hash': 'p',
'portfolio_context_hash': 'a'}},
'verdict': {'verdict': 'PASS', 'reason': 'today', 'degraded': False}, 'auto_exec': True}
self.scan = self.use(ps, 'scan_and_route', side_effect=lambda **kw: {'ok': True, 'review': copy.deepcopy(self.fresh)})
ddl = [
'CREATE TABLE pms_proposal(id INTEGER PRIMARY KEY,proposal_id TEXT UNIQUE,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,status TEXT,expire_at TEXT,decided_at TEXT,judge_verdict TEXT,judge_reason TEXT,archived_at TEXT,created_at TEXT)',
'CREATE TABLE pms_action_ledger(id INTEGER PRIMARY KEY,ts_code TEXT,decided_at TEXT,action TEXT,arbiter TEXT,verdict TEXT,price_at REAL,hard_numbers_json TEXT,failed_checks_json TEXT,reason TEXT,ref_id TEXT,outcome_scored INTEGER)',
'CREATE TABLE pms_instruction(id INTEGER PRIMARY KEY,instruction_id TEXT UNIQUE,origin_type TEXT,origin_id TEXT,ts_code TEXT,action TEXT,side TEXT,qty INTEGER,limit_price REAL,window_tdays INTEGER,status TEXT,exec_qty INTEGER,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT)']
with self.engine.begin() as c:
for sql in ddl: c.execute(text(sql))
pms_repo.insert_instruction(instruction_id='P', origin_type='plan', origin_id='PLAN', ts_code=CODE,
action='OPEN', side='buy', qty=600, limit_price=29, window_tdays=3, status='DISPATCHED',
progress={'deadline': '2026-11-02', 'exec_advice': {'ymd': 20261029, 'buy_band': [28, 29]},
'ref_lock': {'ymd': 20261029}, 'is_command': True})
session.execute('UPDATE pms_instruction SET created_at=:t, exec_qty=0', {'t': '2026-10-29 10:00:00'})
def use(self, obj, name, **kw):
p = patch.object(obj, name, **kw); result = p.start(); self.addCleanup(p.stop); return result
def parent(self): return pms_repo.get_instruction('P')
def run_review(self): return dr.process(now=NOW)
def child(self, state='ACCEPTED', qty=600, done=0):
self.orders = [{'instruction_id': 'P_D01', 'status': state, 'qty': qty, 'cum_qty': done}]
def prop(self): return pms_repo.get_proposal(self.parent()['progress']['daily_review']['proposal_id'])
def accept(self, p=None):
p = p or self.prop()
return dr.decide_confirmation(p, 'ACCEPTED', '交易员确认', p['hard_numbers']['proposal_revision'], now=NOW)
def test_async_pending_keeps_parent_for_later_result(self):
self.scan.side_effect=None
self.scan.return_value={'ok':True,'review':None,
'skipped':[{'ts_code':CODE,'by':'judge_pending','why':'waiting'}]}
result=self.run_review()
self.assertEqual(result['waiting'],['P'])
self.assertEqual(result['ended'],[])
self.assertEqual(self.parent()['status'],'WAIT_REVIEW')
self.scan.return_value={'ok':True,'review':copy.deepcopy(self.fresh)}
self.assertEqual(self.run_review()['approved'],['P'])
def test_old_day_is_blocked_even_with_refreshed_execution_advice(self):
row = self.parent(); row['progress']['exec_advice']['ymd'] = 20261030
self.assertTrue(dr.blocker(row, now=NOW))
def test_today_new_decision_passes_and_missing_date_fails_closed(self):
row = self.parent(); row['created_at'] = NOW
self.assertIsNone(dr.blocker(row, now=NOW))
row['created_at'] = None
self.assertTrue(dr.blocker(row, now=NOW))
def test_old_plan_materialized_today_still_requires_review(self):
row = self.parent(); row['created_at'] = NOW; row['progress']['decision_ymd'] = 20261029
self.assertTrue(dr.blocker(row, now=NOW))
def test_rotation_and_sell_keep_existing_daily_process(self):
row = self.parent(); row['progress']['execution_profile'] = 'rotation'
self.assertIsNone(dr.blocker(row, now=NOW))
row = self.parent(); row['side'] = 'sell'
self.assertIsNone(dr.blocker(row, now=NOW))
def test_maintenance_hold_stays_blocked_even_when_switch_off(self):
self.params['PMS_DAILY_BUY_REVIEW'] = False
row = self.parent(); row['status'] = 'WAIT_REVIEW'
self.assertTrue(dr.blocker(row, now=NOW))
def test_active_child_cancel_request_does_not_reopen_parent(self):
self.child()
r = self.run_review()
self.assertEqual(self.parent()['status'], 'WAIT_REVIEW'); self.assertEqual(r['waiting'], ['P'])
self.scan.assert_not_called(); self.cancel.assert_called_once()
def test_cancel_failure_remains_pending(self):
self.child(); self.cancel.return_value = {'ok': False}
self.assertTrue(self.run_review()['errors']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
def test_late_partial_fill_waits_for_bookkeeping_before_review(self):
self.child('CANCELLED', done=100)
self.run_review(); self.scan.assert_not_called()
pms_repo.update_instruction('P', exec_qty=100)
self.assertEqual(self.run_review()['approved'], ['P'])
self.assertEqual(self.parent()['progress']['daily_review']['start_filled'], 100)
self.assertEqual(self.parent()['exec_qty'], 100)
def test_approval_uses_current_quantity_and_clears_old_price_cache(self):
self.child('EXPIRED')
r = self.run_review(); row = self.parent()
self.assertEqual(r['approved'], ['P']); self.assertEqual(row['status'], 'PROPOSED')
self.assertEqual(row['qty'], 600); self.assertEqual(row['progress']['daily_review']['qty'], 400)
self.assertNotIn('exec_advice', row['progress']); self.assertNotIn('ref_lock', row['progress'])
self.assertIsNone(row['limit_price']); self.assertEqual(self.scan.call_count, 2)
self.assertIsNone(dr.blocker(row, now=NOW)); self.assertTrue(dr.blocker(row, now=NOW + timedelta(days=1)))
def test_approval_does_not_expand_prior_authorization(self):
self.fresh['candidate']['qty'] = 1000
self.run_review()
self.assertEqual(self.parent()['progress']['daily_review']['qty'], 600)
def test_allowance_counts_fills_and_reservations_once(self):
self.run_review(); self.child('ACCEPTED', qty=300, done=100)
pms_repo.update_instruction('P', exec_qty=100)
self.assertEqual(dr.allowance(self.parent(), now=NOW), 100)
self.orders[0]['status'] = 'CANCELLED'
self.assertEqual(dr.allowance(self.parent(), now=NOW), 300)
def test_source_failure_keeps_pending_and_never_reuses_yesterday(self):
self.scan.side_effect = lambda **kw: {'ok': False, 'errors': ['上游失败']}
self.assertTrue(self.run_review()['errors']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
def test_source_changed_during_model_response_requires_new_preparation(self):
changed = copy.deepcopy(self.fresh); changed['candidate']['hard_numbers']['plan_basis'] = {'research': 'new'}
self.scan.side_effect = [{'ok': True, 'review': self.fresh}, {'ok': True, 'review': changed}]
self.assertEqual(self.run_review()['waiting'], ['P']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
def test_disqualified_parent_ends_without_erasing_existing_fill(self):
self.child('CANCELLED', done=100); pms_repo.update_instruction('P', exec_qty=100)
self.scan.side_effect = lambda **kw: {'ok': True, 'review': None, 'skipped': [{'ts_code': CODE, 'why': '排名已不入选'}]}
self.assertEqual(self.run_review()['ended'], ['P']); self.assertEqual(self.parent()['exec_qty'], 100)
self.assertIn('排名', self.parent()['progress']['daily_review']['reason'])
def test_source_command_cancelled_during_review_cannot_resume(self):
row = self.parent(); row['progress']['command_id'] = 'CMD'
pms_repo.update_instruction('P', progress=row['progress'])
self.use(pms_repo, 'get_command', return_value={'status': 'CANCELLED'})
self.assertEqual(self.run_review()['ended'], ['P']); self.scan.assert_not_called()
def test_expired_command_does_not_keep_buying_as_partial(self):
row = self.parent(); row['progress']['deadline'] = '2026-10-29'
pms_repo.update_instruction('P', progress=row['progress'])
self.assertEqual(self.run_review()['ended'], ['P']); self.scan.assert_not_called()
def test_global_pause_prevents_decision_and_resume(self):
self.params['PMS_GLOBAL_BUY_HALT'] = True
self.run_review(); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW'); self.scan.assert_not_called()
def test_auto_accept_is_counted_in_existing_daily_limit(self):
self.fresh['self_decide'] = {'decision': 'accept'}
self.run_review()
self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1)
self.run_review()
self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1)
def test_restart_reuses_today_approval(self):
self.run_review(); n = self.scan.call_count
self.run_review(); self.assertEqual(self.scan.call_count, n)
def test_manual_route_requires_fresh_confirmation(self):
self.fresh['auto_exec'] = False
self.assertEqual(self.run_review()['queued'], ['P']); p = self.prop()
self.assertEqual(p['qty'], 400); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
self.assertTrue(self.accept(p)['ok']); self.assertEqual(self.parent()['status'], 'PROPOSED')
self.assertTrue(self.accept(pms_repo.get_proposal(p['proposal_id']))['already_accepted'])
self.assertEqual(len(pms_repo.list_instructions()), 1)
def test_manual_decline_never_resumes(self):
self.fresh['auto_exec'] = False; self.run_review(); p = self.prop()
r = dr.decide_confirmation(p, 'DECLINED', '不买', p['hard_numbers']['proposal_revision'], now=NOW)
self.assertTrue(r['ok']); self.assertEqual(self.parent()['status'], 'EXPIRED')
def test_changed_manual_basis_invalidates_and_background_reprepares(self):
self.fresh['auto_exec'] = False; self.run_review(); p = self.prop()
self.fresh['candidate']['qty'] = 200
r = self.accept(p); self.assertFalse(r['ok']); self.assertTrue(r['pending'])
self.assertEqual(pms_repo.get_proposal(p['proposal_id'])['status'], 'EXPIRED')
self.assertEqual(self.run_review()['queued'], ['P']); self.assertEqual(self.prop()['qty'], 200)
def test_cancel_during_model_response_cannot_revive_parent(self):
def cancelled(**kw):
pms_repo.update_instruction('P', status='CANCELLED')
return {'ok': True, 'review': self.fresh}
self.scan.side_effect = cancelled
self.run_review(); self.assertEqual(self.parent()['status'], 'CANCELLED')
def test_fill_during_model_response_cannot_overwrite_bookkeeping(self):
def filled(**kw):
pms_repo.update_instruction('P', exec_qty=100)
return {'ok': True, 'review': self.fresh}
self.scan.side_effect = filled
self.run_review(); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
self.assertEqual(self.parent()['exec_qty'], 100)
def test_sql_audit_failure_rolls_back_status_and_manual_decision(self):
self.fresh['auto_exec'] = False; self.run_review(); p = self.prop()
def fail(conn, cursor, statement, *args):
if statement.startswith('INSERT INTO pms_action_ledger'): raise RuntimeError('audit failure')
event.listen(self.engine, 'before_cursor_execute', fail)
try:
with self.assertRaises(RuntimeError): self.accept(p)
finally: event.remove(self.engine, 'before_cursor_execute', fail)
self.assertEqual(self.parent()['status'], 'WAIT_REVIEW')
self.assertEqual(pms_repo.get_proposal(p['proposal_id'])['status'], 'WAIT_USER')
def test_direct_dispatch_and_queued_sender_both_block_old_day(self):
self.use(dispatcher, 'mode', return_value='ws')
self.use(execution_conflicts, 'buy_blocker', return_value=None)
sent = self.use(dispatcher, '_ws')
r = dispatcher.dispatch(instruction_id='P_D01', ts_code=CODE, side='buy', qty=100,
limit_price=30, valid_until=NOW, parent_id='P')
self.assertFalse(r['ok']); sent.assert_not_called()
self.assertTrue(execution_conflicts._queued_parent_check({'parent_id': 'P', 'ts_code': CODE}, self.parent()))
def test_quantity_read_failure_blocks_instead_of_assuming_zero(self):
self.run_review()
self.use(qmt_repo, 'orders_for_parent', side_effect=RuntimeError('db down'))
with self.assertRaises(RuntimeError): dr.allowance(self.parent(), now=NOW)
class ScanIntegrationTests(unittest.TestCase):
def setUp(self):
from test_wiring import install_fakes
from app.services import plan_feed, judge
self.feed, self.judge = plan_feed, judge
self.fake = install_fakes(prices={CODE: 30, '600001.SH': 10}, params={
'PMS_TOTAL_SCALE': 2000000, 'PMS_AUTONOMY': 'full', 'PMS_OPEN_AUTONOMY': 'full',
'PMS_OPEN_REQUIRE_WS_CASH': False, 'PMS_EXEC_WINDOW_TDAYS': 3,
'PMS_CONSENSUS_ROUTE': False, 'PMS_PLAN_TOP_N': 1, 'PMS_CANDIDATE_SOURCE': 'plan_api', 'PMS_PLAN_THEME_CAP': 0})
self.fake.insert_instruction(instruction_id='P', origin_type='plan', origin_id='plan',
ts_code=CODE, action='OPEN', side='buy', qty=600, status='WAIT_REVIEW',
progress={'deadline': '2026-11-02'})
self.parent = self.fake.get_instruction('P')
self.raw = {'date': '2026-10-30', 'rank_axis': 'quality', 'decision': {'id': 'today'},
'main': [{'code': 'SZ300693', 'rank': 1, 'score': 230, 'tier': '强传导',
'upside': .3, 'heat': .2, 'verdict': '候选', 'risk': []}]}
patch.object(plan_feed, 'get_plan', side_effect=lambda **kw: plan_feed.parse_plan(self.raw)).start()
fp = dict(top_n=1, tiers=['强传导'], include_observe=False, min_score=0, min_sources=0,
min_upside=0, theme_cap_local=0, exclude_st=False, rank_by_quality=True,
rank_by_upstream=True, observe_if_fund_bull=False)
patch.object(plan_feed, '_params', return_value=fp).start()
self.request = patch.object(judge, 'request', return_value={'verdict': 'PASS', 'reason': '当日研究',
'confidence': 90, 'degraded': False, 'raw': {'verdict': 'PASS'}}).start()
self.addCleanup(patch.stopall)
def scan(self): return ps.scan_and_route(now=NOW, review_instruction=copy.deepcopy(self.parent))
def test_real_full_scan_excludes_self_and_requests_fresh_judgement(self):
r = self.scan(); self.assertFalse(r['errors'], r); self.assertIsNotNone(r['review'], r)
self.assertTrue(self.request.call_args.kwargs['force'])
self.assertLessEqual(r['review']['candidate']['qty'], 600)
self.assertEqual(len(self.fake.instructions), 1)
def test_rank_cutoff_is_reapplied_not_bypassed_by_old_choice(self):
self.raw['main'].insert(0, dict(self.raw['main'][0], code='SH600001', rank=1, score=250))
self.raw['main'][1]['rank'] = 2
r = self.scan(); self.assertIsNone(r['review'], r); self.request.assert_not_called()
def test_other_inflight_kept_while_self_and_linked_confirmation_excluded(self):
self.fake.insert_instruction(instruction_id='OTHER', origin_type='plan', origin_id='o',
ts_code='600001.SH', action='OPEN', side='buy', qty=100, status='PROPOSED', progress={})
self.fake.insert_proposal(proposal_id='REVIEW', ts_code=CODE, action='OPEN', qty=200,
hard_numbers={'daily_parent': 'P'}, expire_at=NOW)
keys = ps._inflight_keys(exclude_instruction='P')
self.assertNotIn((CODE, 'OPEN'), keys); self.assertIn(('600001.SH', 'OPEN'), keys)
c = ps._inflight_open_commitments({'held': []}, exclude_instruction='P', strict=True)
self.assertEqual(c['names'], {'600001.SH'}); self.assertEqual(c['amount'], 1000)
def test_nonautomatic_verdict_retains_manual_route(self):
self.request.return_value = {'verdict': 'UNAVAILABLE', 'reason': '待人工确认', 'degraded': True}
r = self.scan(); self.assertIsNotNone(r['review'], r); self.assertFalse(r['review']['auto_exec'])
def test_missing_current_source_waits_instead_of_approving(self):
with patch.object(self.feed, 'get_plan', side_effect=self.feed.PlanFeedError('missing')):
r = self.scan()
self.assertTrue(r['errors']); self.assertIsNone(r['review'])
def test_separate_manual_source_is_preserved_and_never_upgraded(self):
from app.services import dividend_feed
self.parent['progress']['plan'] = {'candidate_source': 'dividend'}
selected = self.feed.candidates(record=False)
with patch.object(dividend_feed, 'candidates', return_value=selected) as separate:
r = self.scan()
self.assertIsNotNone(r['review'], r); self.assertFalse(r['review']['auto_exec'])
self.assertTrue(separate.called)
def test_cancel_entire_command_also_cancels_review_waiting_child(self):
from app.services import command_service
self.fake.commands['CMD'] = {'command_id': 'CMD', 'cmd_class': 'task', 'status': 'EXECUTING'}
self.fake.insert_plans([{'command_id': 'CMD', 'plan_id': 'plan', 'status': 'EXECUTING', 'qty': 600}])
with patch.object(dispatcher, 'cancel', return_value={'ok': True}):
r = command_service.cancel('CMD')
self.assertTrue(r['ok'], r); self.assertEqual(r['cancelled'], ['P'])
self.assertEqual(self.fake.get_instruction('P')['status'], 'CANCELLED')
def test_strategy_and_rotation_continue_tracking_review_waits(self):
from app.services import rotation_service, strategy_runner, strategy_advisor
self.assertIn('WAIT_REVIEW', rotation_service.LIVE)
self.assertIn('WAIT_REVIEW', strategy_runner.LIVE_INS)
self.assertTrue(strategy_advisor._has_pending({'state': {'pending': {'iid': 'P'}}}))
def test_prepared_verdict_path_does_not_call_model(self):
r = ps.scan_and_route(now=NOW, review_instruction=copy.deepcopy(self.parent),
prepared_verdict={'verdict': 'PASS', 'reason': '今日已准备', 'degraded': False})
self.assertIsNotNone(r['review'], r); self.request.assert_not_called()
if __name__ == '__main__': unittest.main()