tradingSystem/scripts/test_auto_open_approval.py

193 lines
10 KiB
Python

"""自动建仓名额、待执行指令和批准账本的事务边界。"""
import unit_test_guard # noqa: F401
import sys
import tempfile
import unittest
from concurrent.futures import ThreadPoolExecutor
from contextlib import ExitStack
from datetime import datetime
from pathlib import Path
from threading import Barrier
from unittest.mock import patch
from sqlalchemy import create_engine, event, text
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.db import session
from app.repo import pms_repo
from app.services import judge, param_store, proposal_service as ps
from config.settings import settings
NOW = datetime.now().replace(hour=10, minute=0, second=0, microsecond=0)
CODES = ('600000.SH', '600001.SH')
DDL = [
'CREATE TABLE pms_runtime_param(param_key TEXT PRIMARY KEY, param_value TEXT)',
"INSERT INTO pms_runtime_param VALUES('PMS_SELF_DECIDE','full'), ('PMS_SELF_DECIDE_DAILY_MAX','1')",
'CREATE TABLE pms_ws_state(id INTEGER PRIMARY KEY)',
'INSERT INTO pms_ws_state VALUES(1)',
'''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)''',
'''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_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)''',
]
def candidate(code):
return {'ts_code': code, 'action': 'OPEN', 'side': 'buy', 'qty': 100, 'price': 10.,
'reason': '当前计划合格', 'judge_required': True, 'hard_numbers': {'consensus': {'route': '放行'}}}
class AutoOpenApproval(unittest.TestCase):
def setUp(self):
self.stack = ExitStack()
self.addCleanup(self.stack.close)
root = self.stack.enter_context(tempfile.TemporaryDirectory())
engine = create_engine('sqlite:///' + root + '/ledger.db')
self.stack.callback(engine.dispose)
# SQLite 用短写事务实现与生产账户行锁相同的互斥,事务与所有业务 SQL 仍走真实路径。
@event.listens_for(engine, 'begin')
def begin(conn):
conn.exec_driver_sql('BEGIN IMMEDIATE')
@event.listens_for(engine, 'before_cursor_execute', retval=True)
def locking_sql(conn, cursor, statement, parameters, context, executemany):
return statement.removesuffix(' FOR UPDATE'), parameters
with engine.begin() as conn:
for statement in DDL:
conn.execute(text(statement))
self.use(session, 'get_engine', return_value=engine)
self.use(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', False)
self.use(param_store, 'get_int', side_effect=lambda key, default=0: default)
self.use(param_store, 'get_bool', side_effect=lambda key, default=False: default)
self.use(ps, 'check_candidate_rules', return_value={'passed': True})
self.params = {'self_decide': 'full', 'self_decide_daily_max': 1}
def use(self, owner, name, *args, **kwargs):
return self.stack.enter_context(patch.object(owner, name, *args, **kwargs))
def route(self, code, params=None, out=None):
if out is None:
out = dict(autonomy='full', open_autonomy='full', skipped=[], rejected=[], executed=[], queued=[])
verdict = {'verdict': judge.PASS, 'confidence': 80, 'raw': {'ok': True}, 'reason': '通过'}
ps._route_one(candidate(code), {'positions': []}, params or self.params, {}, False, NOW, False,
out, prepared_verdict=verdict)
return out
def ledger(self):
return session.fetch_all('SELECT * FROM pms_action_ledger')
def test_carried_order_and_new_open_share_last_place(self):
from app.repo import qmt_repo
from app.services import daily_buy_review as daily
self.use(qmt_repo, 'orders_for_parent', return_value=[])
pms_repo.insert_instruction(instruction_id='earlier', origin_type='proposal', origin_id=None,
ts_code=CODES[0], action='OPEN', side='buy', qty=100, status='WAIT_REVIEW', progress={})
parent = pms_repo.get_instruction('earlier')
fresh = {'auto_exec': True, 'candidate': candidate(CODES[0]), 'verdict': {'verdict': 'PASS'},
'self_decide': {'decision': 'accept'}}
gate = Barrier(2)
def existing():
gate.wait()
return daily._finish_review(parent, fresh, NOW)
def new_open():
gate.wait()
return self.route(CODES[1])
with ThreadPoolExecutor(max_workers=2) as pool:
existing_result = pool.submit(existing)
new_result = pool.submit(new_open)
actual = [existing_result.result(), 'approved' if new_result.result()['executed'] else 'queued']
self.assertCountEqual(actual, ['approved', 'queued'])
self.assertEqual(pms_repo.system_pass_count_today(NOW.replace(hour=0)), 1)
self.assertEqual(len(pms_repo.list_proposals(statuses=['WAIT_USER'])), 1)
def test_competing_stocks_share_one_place(self):
gate = Barrier(2)
def route(code):
gate.wait()
return self.route(code)
with ThreadPoolExecutor(max_workers=2) as pool:
results = list(pool.map(route, CODES))
self.assertEqual(sum(len(r['executed']) for r in results), 1)
queued = [p for r in results for p in r['queued']]
self.assertEqual(len(queued), 1)
self.assertIn('上限', queued[0]['why'])
self.assertEqual(len(pms_repo.list_instructions()), 1)
self.assertEqual(pms_repo.system_pass_count_today(NOW.replace(hour=0)), 1)
def test_audit_failure_rolls_back_parent_and_preserves_place(self):
for failure in [RuntimeError('审计写入中断'), 0]:
with self.subTest(failure=failure):
with patch.object(pms_repo, 'insert_ledger', **(
{'side_effect': failure} if isinstance(failure, Exception) else {'return_value': failure})):
with self.assertRaises(RuntimeError):
self.route(CODES[0])
self.assertEqual(pms_repo.list_instructions(), [])
self.assertEqual(self.ledger(), [])
success = self.route(CODES[1])
self.assertEqual(success['_sd_accepts'], 1)
self.assertEqual(self.ledger()[0]['ref_id'], success['executed'][0]['instruction_id'])
def test_parent_write_failure_does_not_consume_a_place_in_the_same_round(self):
out = dict(autonomy='full', open_autonomy='full', skipped=[], rejected=[], executed=[], queued=[])
with patch.object(pms_repo, 'insert_instruction', return_value=0):
with self.assertRaises(RuntimeError):
self.route(CODES[0], out=out)
self.assertEqual(out.get('_sd_accepts', 0), 0)
self.assertEqual(self.ledger(), [])
self.route(CODES[1], out=out)
self.assertEqual(out['_sd_accepts'], 1)
def test_unreadable_count_falls_back_to_manual(self):
with patch.object(pms_repo, 'system_pass_count_today', side_effect=RuntimeError('计数读取失败')):
initial = self.route(CODES[0], dict(self.params, _sd_base_count=ps._auto_open_count(NOW)))
raced = self.route(CODES[1])
for result in (initial, raced):
self.assertIn('无法核实', result['queued'][0]['why'])
self.assertEqual(pms_repo.list_instructions(), [])
self.assertEqual(self.ledger(), [])
def test_disabled_limit_allows_and_duplicate_input_is_idempotent(self):
session.execute("UPDATE pms_runtime_param SET param_value='0' WHERE param_key='PMS_SELF_DECIDE_DAILY_MAX'")
params = {'self_decide': 'full', 'self_decide_daily_max': 0}
with patch.object(pms_repo, 'system_pass_count_today', side_effect=RuntimeError('计数不可读')):
first = self.route(CODES[0], params)
second = self.route(CODES[0], params)
self.assertTrue(first['executed'])
self.assertTrue(second['skipped'])
self.assertEqual(len(pms_repo.list_instructions()), 1)
self.assertEqual(len(self.ledger()), 1)
def test_final_approval_observes_new_limit_and_purchase_halts(self):
self.route(CODES[0])
stale = dict(self.params, self_decide_daily_max=3)
capped = self.route(CODES[1], stale)
self.assertIn('上限 1', capped['queued'][0]['why'])
for flag in ('PMS_GLOBAL_EXEC_HALT', 'PMS_GLOBAL_BUY_HALT'):
with self.subTest(flag=flag):
session.execute('INSERT INTO pms_runtime_param VALUES(:key, :value)', {'key': flag, 'value': 'true'})
stopped = self.route(CODES[1], stale)
self.assertIn('暂停', stopped['skipped'][0]['why'])
session.execute('DELETE FROM pms_runtime_param WHERE param_key=:key', {'key': flag})
self.assertEqual(len(pms_repo.list_instructions()), 1)
def test_non_open_and_manual_decisions_preserve_independent_routes(self):
p = dict(self.params, _sd_base_count=None)
dca = {'action': ps.ae.A_DCA, 'decide_kind': ps.ae.DK_DCA_DEEP}
target = {'action': ps.ae.A_EXIT, 'decide_kind': ps.ae.DK_TARGET_PRICE}
verdict = {'verdict': judge.PASS, 'raw': {}, 'confidence': 90}
self.assertEqual(ps._self_decide(dca, verdict, p, None)['decision'], 'accept')
self.assertEqual(ps._self_decide(target, verdict, p, None)['decision'], 'accept')
already_full = self.route(CODES[0], dict(self.params, _sd_base_count=1))
self.assertTrue(already_full['queued'])
self.assertEqual(pms_repo.list_instructions(), [])
if __name__ == '__main__':
unittest.main()