193 lines
10 KiB
Python
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()
|