tradingSystem/scripts/test_batch51_units.py

315 lines
19 KiB
Python
Raw Normal View History

"""跨日复核:真实单表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)
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_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()