273 lines
15 KiB
Python
273 lines
15 KiB
Python
"""155专用隔离库的轮换验收。合成信号不写运行库,不连接QMT。"""
|
||
import contextlib
|
||
import datetime as dt
|
||
import json
|
||
import multiprocessing as mp
|
||
from pathlib import Path
|
||
import sys
|
||
import unittest
|
||
from unittest.mock import patch
|
||
from urllib.parse import urlsplit
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||
from sqlalchemy import text
|
||
from config.settings import settings
|
||
from app.db import session as db
|
||
from app.core import micro_rotation as core, rotation_account as capital, strategy_book as books
|
||
from app.repo import pms_repo, qmt_repo, rotation_repo as store
|
||
from app.services import rotation_service as service, rotation_execution as execution, param_store
|
||
from init_db import parse_statements
|
||
from migrate_strategy_books import migrate
|
||
|
||
|
||
def guard():
|
||
u = urlsplit(settings.PROXY_DB_URL)
|
||
assert u.hostname == 'micro30-acceptance-db' and u.path == '/micro30_acceptance_20261028'
|
||
assert not settings.PMS_TABLE_PREFIX
|
||
|
||
|
||
def snapshot(day, *, low=False, high=False, dropped=False):
|
||
import hashlib
|
||
codes = [f'{600100+i}.SH' for i in range(30)]
|
||
if dropped:
|
||
codes[0] = '600999.SH'
|
||
data_day = (dt.date.fromisoformat(day)-dt.timedelta(days=1)).isoformat()
|
||
value = {'rule_version': core.RULE, 'basket_size': 30, 'data_date': data_day,
|
||
'effective_date': day, 'signal_ready': True, 'basket_ready': True,
|
||
'signal': {'date': data_day, 'ready': True, 'growth_break': False, 'low': low, 'high': high},
|
||
'members': [{'code': c, 'rank': i+1, 'eligible': True, 'close': 10., 'total_mv_wan': i+1} for i, c in enumerate(codes)],
|
||
'source_hashes': {'fixture': 'isolated-only'}, 'errors': []}
|
||
value['snapshot_version'] = hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode()).hexdigest()
|
||
value['frozen'] = True
|
||
return value
|
||
|
||
|
||
def funds(cash=50000, seq=100):
|
||
return {'seq': seq, 'age_sec': 0, 'received_at': dt.datetime.now(),
|
||
'payload': {'kind': 'funds', 'data': {'available_cash': cash, 'frozen_cash': 0,
|
||
'market_value': 0, 'total_asset': cash}}}
|
||
|
||
|
||
def parent(iid, book='micro30', code='600100.SH', qty=100, side='buy', t0=False):
|
||
with books.scope(book):
|
||
pms_repo.insert_instruction(instruction_id=iid, origin_type='strategy' if t0 else 'plan',
|
||
origin_id=None, ts_code=code, action='T0_ROUND' if t0 else ('OPEN' if side == 'buy' else 'EXIT'),
|
||
side=side, qty=qty, progress={'leg': 'close'} if t0 else {})
|
||
|
||
|
||
def payload(iid, code='600100.SH', qty=100, side='buy'):
|
||
return {'instruction_id': iid+'_D01', 'ts_code': code, 'side': side, 'qty': qty,
|
||
'limit_price': 10., 'valid_until': int((dt.datetime.now()+dt.timedelta(hours=1)).timestamp()*1000), 'intent': 'OPEN' if side == 'buy' else 'EXIT'}
|
||
|
||
|
||
def race_worker(iid, code, gate, out):
|
||
guard()
|
||
settings.INFRA_STRATEGY_BOOK_SCHEMA = True
|
||
settings.INFRA_ROTATION_DOCUMENT_SCHEMA = True
|
||
with patch.object(qmt_repo, 'latest_snapshot', return_value=funds()), \
|
||
patch('app.services.rotation_accounting.marked_values', return_value=({'original': 0., 'micro30': 0.}, [])):
|
||
gate.wait(15)
|
||
try:
|
||
execution.enqueue_with_reservation(payload(iid, code, 3000), iid)
|
||
out.put((iid, 'accepted'))
|
||
except ValueError as exc:
|
||
out.put((iid, str(exc)))
|
||
|
||
|
||
class Acceptance(unittest.TestCase):
|
||
def setUp(self):
|
||
guard()
|
||
self.stack = contextlib.ExitStack()
|
||
self.addCleanup(self.stack.close)
|
||
with db.get_engine().begin() as c:
|
||
for table in sorted(books.TABLES | {'pms_qmt_order', 'pms_qmt_inbox', 'pms_rotation_document', 'pms_runtime_param'}):
|
||
c.execute(text('DELETE FROM '+table))
|
||
for key, value in {'PMS_ROTATION_MODE': 'auto', 'PMS_ROTATION_CONTROL': 'run',
|
||
'PMS_GLOBAL_EXEC_HALT': False, 'PMS_GLOBAL_BUY_HALT': False,
|
||
'PMS_TOTAL_SCALE': 1000000., 'PMS_PORTFOLIO_CAP': .7, 'PMS_CASH_RESERVE': 0.,
|
||
'PMS_MICRO30_COMMISSION_RATE': .0002, 'PMS_MICRO30_ALLOWED_BOARDS': 'MAIN,STAR,CHINEXT'}.items():
|
||
assert param_store.set_param(key, value, 'isolated_rehearsal')['ok']
|
||
self.now = dt.datetime(2024, 1, 2, 9, 31, tzinfo=service.TZ)
|
||
self.snap = snapshot('2024-01-02', low=True)
|
||
self.prices = {}
|
||
self.mock(service, 'pull', side_effect=lambda *a: self.snap)
|
||
self.mock(service.td, 'calendar_degraded', return_value=False)
|
||
self.mock(service.td, 'is_trade_day', return_value=True)
|
||
self.mock(service, 'activation_errors', return_value=[])
|
||
self.mock(service, '_limits', side_effect=lambda *a: {c: {'up_limit': 11., 'down_limit': 9.} for c in [f'{600100+i}.SH' for i in range(30)]+['600999.SH']})
|
||
self.mock(service, '_quote', side_effect=lambda c, now: {'price': self.prices.get(c, 10.), 'bar_time': now.isoformat()})
|
||
self.mock(service.portfolio, 'cash_view', return_value={'source': 'ws', 'cash_avail': 300000., 'total_asset': 300000.})
|
||
self.stack.enter_context(patch('app.services.command_service.blacklist', return_value=set()))
|
||
|
||
def mock(self, obj, name, **kwargs):
|
||
return self.stack.enter_context(patch.object(obj, name, **kwargs))
|
||
|
||
def test_cross_process_funding_has_one_winner(self):
|
||
store.put_once('state:live', 'state', {'rotation': {**core.initial_state(), 'phase': 'entering_micro'}})
|
||
store.put_once('capital:live', 'capital', capital.seed(50000, {}))
|
||
parent('A', book='original', code='600101.SH', qty=3000, t0=True)
|
||
parent('B', code='600102.SH', qty=3000)
|
||
ctx = mp.get_context('spawn'); gate = ctx.Event(); out = ctx.Queue()
|
||
procs = [ctx.Process(target=race_worker, args=(i, c, gate, out)) for i, c in [('A', '600101.SH'), ('B', '600102.SH')]]
|
||
for p in procs: p.start()
|
||
gate.set()
|
||
results = [out.get(timeout=30) for _ in procs]
|
||
for p in procs:
|
||
p.join(10); self.assertEqual(p.exitcode, 0)
|
||
self.assertEqual(sum(v == 'accepted' for _, v in results), 1, results)
|
||
self.assertEqual(len(qmt_repo.list_orders()), 1)
|
||
reservation, _ = store.get('account-execution')
|
||
self.assertEqual(len(reservation['orders']), 1)
|
||
self.assertLess(sum(reservation['orders'].values()), 50000)
|
||
|
||
def test_exit_signal_survives_failed_cancel_and_restart(self):
|
||
state = {**core.initial_state(), 'phase': 'entering_micro', 'target': ['600100.SH'], 'cycle': 1}
|
||
store.put_once('state:live', 'state', {'rotation': state})
|
||
with books.scope('micro30'):
|
||
pms_repo.ensure_position('600100.SH')
|
||
pms_repo.bump_position_qty('600100.SH', total_delta=100, avail_delta=100)
|
||
parent('old-buy', code='600101.SH')
|
||
self.snap = snapshot('2024-01-02', high=True)
|
||
self.mock(service, 'reconcile_books', return_value={'ok': True, 'diffs': []})
|
||
from app.services import executor
|
||
self.mock(executor, 'cancel_instruction', return_value={'ok': False, 'error': 'fixture cancel unavailable'})
|
||
try:
|
||
service.tick(self.now)
|
||
except RuntimeError:
|
||
pass
|
||
stored, _ = store.get('state:live')
|
||
self.assertEqual(stored['rotation']['phase'], 'returning_original')
|
||
self.assertEqual(stored['rotation']['exit_date'], '2024-01-02')
|
||
self.assertEqual(qmt_repo.list_orders(), [])
|
||
self.snap = None # 下一跳模拟重启后监控失联,退出事实仍须存在。
|
||
try:
|
||
service.tick(self.now+dt.timedelta(minutes=1))
|
||
except RuntimeError:
|
||
pass
|
||
self.assertEqual(store.get('state:live')[0]['rotation']['phase'], 'returning_original')
|
||
|
||
def test_entry_is_saved_before_cancel_failure(self):
|
||
parent('original-buy', book='original', code='600101.SH')
|
||
self.mock(service, 'reconcile_books', return_value={'ok': True, 'diffs': []})
|
||
from app.services import executor
|
||
self.mock(executor, 'cancel_instruction', return_value={'ok': False})
|
||
with self.assertRaises(RuntimeError):
|
||
service.tick(self.now)
|
||
stored, _ = store.get('state:live')
|
||
self.assertEqual(stored['rotation']['phase'], 'entering_micro')
|
||
self.assertEqual(stored['rotation']['consumed_entry'], self.snap['snapshot_version'])
|
||
self.assertIsNotNone(service.original_buy_blocker())
|
||
self.assertEqual(qmt_repo.list_orders(), [])
|
||
|
||
def test_zero_positions_wait_for_downstream_cancel(self):
|
||
store.put_once('state:live', 'state', {'rotation': {**core.initial_state(), 'phase': 'entering_micro', 'cycle': 1}})
|
||
parent('old-buy')
|
||
qmt_repo.enqueue_order(**{**payload('old-buy'), 'parent_id': 'old-buy'})
|
||
self.snap = snapshot('2024-01-02', high=True)
|
||
self.mock(service, 'reconcile_books', return_value={'ok': True, 'diffs': []})
|
||
from app.services import dispatcher
|
||
self.mock(dispatcher, 'mode', return_value='ws')
|
||
self.mock(dispatcher, 'channel_status', return_value={'online': True})
|
||
service.tick(self.now)
|
||
self.assertEqual(store.get('state:live')[0]['rotation']['phase'], 'returning_original')
|
||
with books.scope('micro30'):
|
||
self.assertEqual(pms_repo.get_instruction('old-buy')['status'], 'CANCELLED')
|
||
child = qmt_repo.get_order('old-buy_D01')
|
||
self.assertEqual(child['cancel_state'], 'REQUESTED')
|
||
self.assertNotIn(child['status'], qmt_repo.FINAL)
|
||
self.snap = None
|
||
service.tick(self.now+dt.timedelta(minutes=1))
|
||
self.assertEqual(store.get('state:live')[0]['rotation']['phase'], 'returning_original')
|
||
db.execute("UPDATE pms_qmt_order SET status='CANCELLED' WHERE instruction_id='old-buy_D01'")
|
||
service.tick(self.now+dt.timedelta(minutes=2))
|
||
self.assertEqual(store.get('state:live')[0]['rotation']['phase'], 'original')
|
||
self.assertEqual(len(qmt_repo.list_orders()), 1)
|
||
|
||
def test_exit_survives_missing_validation_and_limit_service(self):
|
||
store.put_once('state:live', 'state', {'rotation': {**core.initial_state(), 'phase': 'micro', 'cycle': 1}})
|
||
with books.scope('micro30'):
|
||
pms_repo.ensure_position('600100.SH')
|
||
pms_repo.bump_position_qty('600100.SH', total_delta=100, avail_delta=100)
|
||
self.snap = snapshot('2024-01-02', high=True)
|
||
self.mock(service, 'activation_errors', return_value=['验收记录暂不可用'])
|
||
self.mock(service, 'reconcile_books', return_value={'ok': True, 'diffs': []})
|
||
self.mock(service, '_limits', side_effect=RuntimeError('fixture limits unavailable'))
|
||
with self.assertRaises(RuntimeError):
|
||
service.tick(self.now)
|
||
stored, _ = store.get('state:live')
|
||
self.assertEqual(stored['rotation']['phase'], 'returning_original')
|
||
self.assertEqual(stored['rotation']['reason'], '微盘活跃度高位')
|
||
self.assertEqual(qmt_repo.list_orders(), [])
|
||
|
||
def test_user_conflict_keeps_pause_when_cancel_fails(self):
|
||
store.put_once('state:live', 'state', {'rotation': {**core.initial_state(), 'phase': 'micro'}})
|
||
parent('old-buy')
|
||
with books.scope('micro30'):
|
||
pms_repo.update_instruction('old-buy', progress={'execution_profile': 'rotation'})
|
||
from app.services import executor
|
||
self.mock(executor, 'cancel_instruction', return_value={'ok': False})
|
||
with self.assertRaises(RuntimeError):
|
||
service.on_user_command('REDUCE_EXPOSURE', 'manual-1', 'trader')
|
||
self.assertEqual(param_store.get('PMS_ROTATION_CONTROL'), 'pause_all')
|
||
self.assertIsNotNone(service.strategy_buy_blocker('micro30'))
|
||
|
||
def test_paper_full_cycle_is_separate_and_residual_blocks_reentry(self):
|
||
assert param_store.set_param('PMS_ROTATION_MODE', 'paper', 'isolated_rehearsal')['ok']
|
||
service.tick(self.now)
|
||
service.tick(self.now+dt.timedelta(minutes=1))
|
||
first, _ = store.get('state:paper')
|
||
self.assertEqual(first['rotation']['phase'], 'micro')
|
||
self.assertEqual(sum(p['qty'] > 0 for p in first['account']['books']['micro30'].values()), 30)
|
||
fill_count = len(first['account']['fills'])
|
||
service.tick(self.now+dt.timedelta(minutes=2))
|
||
self.assertEqual(len(store.get('state:paper')[0]['account']['fills']), fill_count)
|
||
retained = first['account']['books']['micro30']['600101.SH']['qty']
|
||
self.snap = snapshot('2024-01-03', dropped=True)
|
||
service.tick(self.now+dt.timedelta(days=1))
|
||
rolled, _ = store.get('state:paper')
|
||
self.assertEqual(rolled['account']['books']['micro30']['600101.SH']['qty'], retained)
|
||
self.assertEqual(rolled['account']['books']['micro30']['600100.SH']['qty'], 0)
|
||
self.assertGreater(rolled['account']['books']['micro30']['600999.SH']['qty'], 0)
|
||
self.snap = snapshot('2024-01-04', high=True, dropped=True)
|
||
self.prices['600101.SH'] = 9. # 跌停不能退出,留下残余。
|
||
service.tick(self.now+dt.timedelta(days=2))
|
||
returning, _ = store.get('state:paper')
|
||
self.assertEqual(returning['rotation']['phase'], 'returning_original')
|
||
self.assertEqual(sum(p['qty'] > 0 for p in returning['account']['books']['micro30'].values()), 1)
|
||
self.snap = snapshot('2024-01-05', low=True, dropped=True)
|
||
service.tick(self.now+dt.timedelta(days=3))
|
||
self.assertEqual(store.get('state:paper')[0]['rotation']['cycle'], 1)
|
||
self.prices.clear()
|
||
service.tick(self.now+dt.timedelta(days=3, minutes=1))
|
||
service.tick(self.now+dt.timedelta(days=3, minutes=2))
|
||
closed, _ = store.get('state:paper')
|
||
self.assertEqual(closed['rotation']['phase'], 'original')
|
||
self.assertEqual(closed['rotation']['cycle'], 1)
|
||
self.assertEqual(qmt_repo.list_orders(), [])
|
||
for table in ['pms_position', 'pms_lot', 'pms_instruction', 'pms_action_ledger', 'pms_cash_flow']:
|
||
with books.scope('all'):
|
||
self.assertEqual(db.fetch_one('SELECT COUNT(*) AS n FROM '+table)['n'], 0)
|
||
self.assertEqual(store.recent('paper_day'), []) # 历史回放不生成自然纸面日。
|
||
|
||
|
||
def main():
|
||
guard()
|
||
settings.INFRA_STRATEGY_BOOK_SCHEMA = False
|
||
with db.get_engine().begin() as c:
|
||
if not c.execute(text('SHOW TABLES')).all():
|
||
for kind, table, sql in parse_statements((Path(__file__).resolve().parents[1]/'ddl_pms_v1.sql').read_text()):
|
||
assert kind != '?'; c.execute(text(sql))
|
||
migration = migrate(True)
|
||
migrate(True)
|
||
settings.INFRA_STRATEGY_BOOK_SCHEMA = True
|
||
settings.INFRA_ROTATION_DOCUMENT_SCHEMA = True
|
||
result = unittest.TextTestRunner(verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(Acceptance))
|
||
print(json.dumps({'environment': '155专用内部网络隔离库,合成历史信号,无QMT',
|
||
'migration_tables': len(migration), 'tests': result.testsRun, 'failures': len(result.failures),
|
||
'errors': len(result.errors), 'natural_days_created': 0, 'status': 'PASS' if result.wasSuccessful() else 'FAIL'}, ensure_ascii=False))
|
||
raise SystemExit(0 if result.wasSuccessful() else 1)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|