diff --git a/QMT_WS_PROTOCOL.md b/QMT_WS_PROTOCOL.md index a1586ec..e0d1be0 100644 --- a/QMT_WS_PROTOCOL.md +++ b/QMT_WS_PROTOCOL.md @@ -201,6 +201,10 @@ def sign(seed_hex, canon): QMT 撤在途部分,已成交部分保留。撤单完成后该指令进入 `CANCELLED` 终态(若撤单前已全成,则回 `reject{code:"ALREADY_FINAL"}` 并附当前状态)。 +2026-10-30补充:155启用`PMS_EXEC_QMT_DAY_ORDER`时,普通QMT限价委托的`valid_until`给到当日15:00;微盘轮换、网格和做T各自的窗口不变。已发送委托不原地改有效期,新委托按新规则生成。次日买入仍须完整决策复核。 + +撤单请求已发送不等于券商撤单成功。`reject`若对应撤单,不能把原委托改成`REJECTED`;`ALREADY_FINAL`也不能替代带累计成交量的终态回报。部分成交后撤单的`cum_qty`必须保留实际累计成交,逐笔`trade`仍须完整推送。PMS停止父任务新增后,仍跟踪子委托、保留在途占用并按原策略接收迟到成交。发送前持久标记可能已发出,重启恢复后的排队单若曾尝试发送,仍向QMT撤单并等终态,不能直接本地作废。 + ### 4.4 查询类 | type | payload | 回应 | diff --git a/app/core/exec_timing.py b/app/core/exec_timing.py index 77c12b5..b90c07e 100644 --- a/app/core/exec_timing.py +++ b/app/core/exec_timing.py @@ -440,8 +440,8 @@ def add_trade_minutes(start_min: int, minutes: int) -> int: def slice_deadline(now, *, ttl_min: int = 10, forced: bool = False) -> int: """单个下发分片的有效期截止 (当日分钟数)。下游到点未成交即自动撤单。 - 普通分片只给 ttl_min 个交易分钟: run_tick 每分钟重评一次, 撤掉重下比挂着更好 - —— 限价是按下发那一刻的价算的, 挂久了价已经不是那个价, 还白占可用资金/持仓。 + 短时分片给 ttl_min 个交易分钟,到期后允许按新依据再评估。 + 普通QMT限价单启用当日有效时,由调用方选择收盘截止。 兜底单 (14:45 之后的 forced) 直接给到收盘: 那是「今天必须走掉」的单, 不能被 TTL 撤回来。 """ diff --git a/app/repo/qmt_repo.py b/app/repo/qmt_repo.py index bd6be52..04b7a9d 100644 --- a/app/repo/qmt_repo.py +++ b/app/repo/qmt_repo.py @@ -417,8 +417,17 @@ def claim_order(instruction_id: str) -> bool: return bool(n) +def mark_send_attempt(instruction_id: str) -> bool: + """发送前持久标记可能已发出;进程崩溃或网络超时后不能按未发单释放占用。""" + return bool(execute("UPDATE pms_qmt_order SET sent_at = :ts, updated_at = :ts " + "WHERE instruction_id = :iid AND status = 'SENDING' " + "AND cancel_state = 'NONE'", {"iid": instruction_id, "ts": _NOW()})) + + def mark_sent(instruction_id: str) -> int: - return execute("UPDATE pms_qmt_order SET status = 'SENT', sent_at = :ts, " + # 回报可能在 send() 返回前已被消费,不能把 ACCEPTED/PARTIAL/终态写回 SENT。 + return execute("UPDATE pms_qmt_order SET status = CASE WHEN status = 'SENDING' " + "THEN 'SENT' ELSE status END, sent_at = :ts, " "send_attempts = send_attempts + 1, updated_at = :ts " "WHERE instruction_id = :iid", {"iid": instruction_id, "ts": _NOW()}) @@ -439,7 +448,7 @@ def requeue_order(instruction_id: str, error: str = "", max_attempts: int = 3, "status = CASE WHEN send_attempts + :inc >= :mx THEN 'SEND_FAILED' " " ELSE 'QUEUED' END, " "send_attempts = send_attempts + :inc, " - "reject_reason = :err, updated_at = :ts WHERE instruction_id = :iid", + "reject_reason = :err, updated_at = :ts WHERE instruction_id = :iid AND status = 'SENDING'", {"iid": instruction_id, "mx": int(max_attempts), "err": str(error)[:300], "inc": 1 if count_attempt else 0, "ts": _NOW()}) @@ -460,7 +469,7 @@ def abort_order(instruction_id: str, note: str) -> int: now = _NOW() return execute("UPDATE pms_qmt_order SET status = 'ABORTED', reject_code = 'LOCAL_ABORT', " "reject_reason = :nt, final_at = :ts, updated_at = :ts " - "WHERE instruction_id = :iid", + "WHERE instruction_id = :iid AND status IN ('QUEUED','SENDING') AND sent_at IS NULL", {"iid": instruction_id, "nt": str(note)[:300], "ts": now}) @@ -488,6 +497,14 @@ def request_cancel(*, parent_id: str, cancel_id: str) -> int: f"AND cancel_state = 'NONE' AND status IN ({_in_clause(list(LIVE), 'lv', p)})", p) +def request_order_cancel(instruction_id: str, cancel_id: str, note: str) -> int: + """只收回这张可能已经发出的委托,不能用本地作废代替QMT确认。""" + p = {'iid': instruction_id, 'cid': cancel_id, 'nt': note[:300], 'ts': _NOW()} + return execute("UPDATE pms_qmt_order SET cancel_state='REQUESTED', cancel_id=:cid, " + "cancel_req_at=:ts, note=:nt, updated_at=:ts WHERE instruction_id=:iid " + f"AND cancel_state='NONE' AND status IN ({_in_clause(list(LIVE), 'lv', p)})", p) + + def next_cancel_requests(limit: int = 20) -> list: p = {"n": int(limit)} return fetch_all( diff --git a/app/services/dispatcher.py b/app/services/dispatcher.py index 75b3043..48f9382 100644 --- a/app/services/dispatcher.py +++ b/app/services/dispatcher.py @@ -267,14 +267,17 @@ def cancel(*, instruction_id: str, dispatch_ref=None) -> dict: try: cancel_id = wsc.new_cancel_id(int(datetime.now().strftime("%Y%m%d"))) n = qmt_repo.request_cancel(parent_id=instruction_id, cancel_id=cancel_id) + pending = any(o.get('status') in qmt_repo.LIVE + for o in qmt_repo.orders_for_parent(instruction_id)) except Exception as e: logger.exception("撤单请求落表失败 %s", instruction_id) return {"ok": False, "mode": m, "error": f"{type(e).__name__}: {e}"} if not n: - return {"ok": True, "mode": m, "cancelled": 0, - "note": "该指令名下没有在途子单, 仅本地置撤销"} + return {"ok": True, "mode": m, "cancelled": 0, "cancel_pending": pending, + "note": "撤单已在处理中,等待QMT终态" if pending else "该指令名下没有在途子单, 仅本地置撤销"} note = f"已标记 {n} 张在途委托待撤 (cancel_id={cancel_id})" ch = channel_status() if not ch["online"]: note += f"; 连接当前 {ch['conn_state']}, 重连后发出" - return {"ok": True, "mode": m, "cancelled": n, "cancel_id": cancel_id, "note": note} + return {"ok": True, "mode": m, "cancelled": n, "cancel_pending": pending, + "cancel_id": cancel_id, "note": note} diff --git a/app/services/executor.py b/app/services/executor.py index a49641e..b662f9a 100644 --- a/app/services/executor.py +++ b/app/services/executor.py @@ -373,7 +373,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: "reason": d["reason"], "dry_run": True}) continue - dl_min = et.slice_deadline(now, ttl_min=order_ttl, forced=d.get("forced", False)) + dl_min = order_deadline(now, d, ttl_min=order_ttl) # intent / parent_id / note 是 ws 通道要的 (协议 §4.2): intent 只作归类, # parent_id 让子单能回指父指令, note 原样落到 QMT 侧供人工看盘。 # shadow 模式忽略这三项, 传着不碍事 —— 两种模式共用同一个调用点。 @@ -487,10 +487,8 @@ def cancel_instruction(instruction_id: str, reason: str = "页面人工撤销", return {"ok": False, "error": f"指令处于 {ins['status']}, 不可撤销"} r = dispatcher.cancel(instruction_id=instruction_id, dispatch_ref=ins.get("dispatch_ref")) or {} - # **下游没撤成就不能在本端标 CANCELLED。** 原来 r 拿到手却从不检查, 一律回「已撤销」 - # 并把父指令置终态 —— 而终态之后没有任何东西再跟踪它, 下游那张委托继续挂着、继续成交, - # 成交回来还会因为找不到在途父指令而变成孤儿。撤不掉就保持在途, 让它继续被择时/收口/ - # 对账看见, 由人再处理。 + # ok 只表示撤单意图已落表。父指令停止新增,子委托仍按QMT回报跟踪, + # 在途占用及迟到成交不因父指令 CANCELLED 而清除。 if not r.get("ok"): logger.error("[撤单] 下游未受理 %s: %s —— 指令保持在途, 下游委托可能仍挂着", instruction_id, r.get("error") or r) @@ -508,10 +506,21 @@ def cancel_instruction(instruction_id: str, reason: str = "页面人工撤销", pms_repo.insert_ledger(ts_code=ins["ts_code"], action=ins.get("action"), arbiter=arbiter, verdict="REJECT", price_at=0, ref_id=instruction_id, reason=reason, hard_numbers=(ins.get('progress') or {}).get('plan') or {}) - return {"ok": True, "downstream": r, "message": f"指令 {instruction_id} 已撤销"} + pending = dispatcher.mode() == dispatcher.MODE_WS and bool(r.get('cancel_pending')) + return {"ok": True, "downstream": r, "cancel_pending": pending, + "message": (f"指令 {instruction_id} 已停止新增,撤单处理中,已成交部分仍会入账" + if pending else f"指令 {instruction_id} 已撤销")} # ================================================================ 内部 +def order_deadline(now, decision, *, ttl_min): + # 仅作用于普通执行器的QMT价格监控路径。轮换、网格和做T各自决定有效期。 + day_order = (decision.get('qmt_price_monitor') + and param_store.get_bool('PMS_EXEC_QMT_DAY_ORDER', False)) + return et.slice_deadline(now, ttl_min=ttl_min, + forced=bool(decision.get('forced') or day_order)) + + def _pos_of(view: dict, ts_code: str) -> dict: for x in view["positions"]: if x["ts_code"] == ts_code: diff --git a/app/services/param_store.py b/app/services/param_store.py index 93480ba..8eea0be 100644 --- a/app/services/param_store.py +++ b/app/services/param_store.py @@ -281,6 +281,7 @@ DESC = { "PMS_DISPATCH_MODE": "下发通道: shadow=只记账待人工 / ws=WebSocket 直连 QMT (需先起 pms-ws)", "PMS_EXEC_SLICES": "当日配额分几笔出手", "PMS_ORDER_TTL_MIN": "单笔挂单有效期 (交易分钟), 到点下游自动撤; 兜底单不受限", + "PMS_EXEC_QMT_DAY_ORDER": "普通QMT限价单当日有效,最晚15:00撤单;不改变微盘和网格的执行窗口", "PMS_SELL_BUCKET_TIMES": "卖出分桶收口时点 (逗号分隔, 如 11:30,14:00): 桶内照旧择价, 桶收口无条件补齐该桶份额, 把跌日的强制卖出从 14:45 一根针分散到多个时点; 留空=不分桶回到旧行为", "PMS_URGENT_SELL_DISCOUNT": "紧急卖出限价系数 (一键清仓/高置信风控清仓直通出手, 比兜底 0.998 更激进, 每分钟按新现价重定)", "PMS_RISK_WARN_ENTRY": "单笔敞口告警线 (占规模)", "PMS_RISK_WARN_PORTFOLIO": "组合敞口告警线", diff --git a/app/ws/runner.py b/app/ws/runner.py index 206c95d..71659c3 100644 --- a/app/ws/runner.py +++ b/app/ws/runner.py @@ -675,6 +675,18 @@ class WsRunner: n, json.dumps(pl, ensure_ascii=False)[:500]) self._maybe_degrade_ack(pl) else: + row = await _db(qmt_repo.get_order, iid) or {} + cur = str(row.get('status') or '').upper() + # 撤单拒绝不等于原委托拒绝。ALREADY_FINAL 也可能先于终态回报到达; + # 缺累计成交量时保持原占用,等待 order_update 与 trade,不猜成交数。 + cancelling = row.get('cancel_state') in ('REQUESTED', 'SENT') + if cur in qmt_repo.FINAL or cancelling or code == 'ALREADY_FINAL': + self._note_orphan(await _db(qmt_repo.update_order, iid, + reject_code=code[:32], reject_reason=str(pl.get('reason') or '')[:300]), + type_, iid) + logger.warning('[reject] %s 撤单或终态响应 %s,保留委托状态 %s 和成交数量,等待最终核对', + iid, code, cur) + return n = await _db(qmt_repo.update_order, iid, status=qmt_repo.OS_REJECTED, reject_code=code[:32], reject_reason=str(pl.get("reason") or "")[:300], @@ -722,6 +734,18 @@ class WsRunner: status = str(pl.get("status") or "").upper() row = await _db(qmt_repo.get_order, iid) or {} cur = str(row.get("status") or "").upper() + done = pl.get('cum_qty') + try: + done = int(done) + if done < int(row.get('cum_qty') or 0) or done > int(row['qty']) or done < 0: + raise ValueError('累计成交倒退或超出委托数量') + if status == wsc.ST_FILLED and done != int(row['qty']): + raise ValueError('全成状态与累计成交数量不符') + except (TypeError, ValueError, KeyError) as exc: + self._stat['order_update_conflicts'] = self._stat.get('order_update_conflicts', 0) + 1 + self._stat['last_order_conflict'] = f'{iid}: {exc}' + logger.error('[order_update] %s 累计成交不可核实,保留原委托占用: %s', iid, exc) + return if wsc.is_final(cur) and status != cur: # §5.4/§7.1: 终态唯一、不可再变、只推一次。真收到第二条终态说明对端有 bug —— # 此时**保住第一条**: 账本记的是"到底成交了多少", 被一条迟到的 CANCELLED 覆盖掉 @@ -729,7 +753,7 @@ class WsRunner: logger.error("[order_update] %s 已是终态 %s, 又收到 %s —— 已忽略, 请核对对端实现", iid, cur, status) return - fields = {"status": status, "cum_qty": int(pl.get("cum_qty") or 0)} + fields = {"status": status, "cum_qty": done} if pl.get("cum_avg_price") is not None: fields["cum_avg_price"] = float(pl["cum_avg_price"]) if pl.get("leaves_qty") is not None: @@ -865,8 +889,7 @@ class WsRunner: if int(r["valid_until"] or 0) <= now: # 排队期间就过期了。发出去只会立刻换回一个 EXPIRED, 白跑一趟还占对端一条 # 记录 —— 本地作废更干净, executor 下一跳会按新行情重新出手。 - await _db(qmt_repo.abort_order, iid, "排队期间 valid_until 已过, 未发出即作废") - logger.warning("[outbox] %s 有效期已过, 本地作废未发出", iid) + await self._stop_outbox_order(iid, "排队期间 valid_until 已过") continue if not await _db(qmt_repo.claim_order, iid): continue # 被别的进程抢走了 (滚动重启的瞬间) @@ -874,7 +897,7 @@ class WsRunner: # 排队后可能发生清仓或撤单。认领后再核对,未知状态保留重试。 fresh = await _db(qmt_repo.get_order, iid) if not fresh or fresh.get('cancel_state') in ('REQUESTED', 'SENT'): - await _db(qmt_repo.abort_order, iid, '发出前撤销') + await self._stop_outbox_order(iid, '发出前撤销') continue from app.services.execution_conflicts import queued_buy_blocker try: @@ -885,20 +908,24 @@ class WsRunner: logger.warning('[outbox] %s 买入依据暂不可核实,保留队列', iid) continue if blocked: - await _db(qmt_repo.abort_order, iid, blocked) + await self._stop_outbox_order(iid, blocked) continue payload = wsc.place_order_payload( instruction_id=iid, ts_code=r["ts_code"], side=r["side"], qty=int(r["qty"]), limit_price=r["limit_price"], valid_until=int(r["valid_until"]), intent=r.get("intent") or "OPEN", note=r.get("note") or "") + if not await _db(qmt_repo.mark_send_attempt, iid): + continue # 同时发生撤单或状态改变,不再发送。 await self._send(wsc.T_PLACE, payload, seed, corr_id=iid) except Exception as e: # 连接断了不算这张单的"失败次数" —— 那是通道的问题不是这张单的问题, # 否则一次几秒的网络抖动就能把三张待发单全部烧成 SEND_FAILED。 conn = _is_conn_error(e) + # 已进入传输阶段则无法证明对端未收到,必须保留在途与幂等键。 + attempted = await _db(qmt_repo.get_order, iid) await _db(qmt_repo.requeue_order, iid, f"{type(e).__name__}: {e}", - self._p("max_attempts", 3), not conn) + self._p("max_attempts", 3), not conn and not bool((attempted or {}).get('sent_at'))) logger.warning("[outbox] %s 发送失败%s: %s", iid, " (连接问题, 不计失败次数)" if conn else "", e) raise @@ -906,11 +933,21 @@ class WsRunner: logger.info("[outbox] 已发出 %s %s %s %s股 @%.2f", iid, r["ts_code"], r["side"], r["qty"], float(r["limit_price"])) + async def _stop_outbox_order(self, iid: str, reason: str): + row = await _db(qmt_repo.get_order, iid) or {} + if row.get('sent_at'): + # 包括重启恢复后的 QUEUED:曾尝试发送就必须向QMT撤单并等回报。 + n = await _db(qmt_repo.request_order_cancel, iid, wsc.new_cancel_id(_ymd()), reason) + if not n and row.get('cancel_state') not in ('REQUESTED', 'SENT') and row.get('status') in qmt_repo.LIVE: + raise RuntimeError('待撤意图未写入,保留委托占用') + else: + await _db(qmt_repo.abort_order, iid, reason) + async def _drain_cancels(self, seed: str): rows = await _db(qmt_repo.next_cancel_requests, 20) for r in rows: iid = r["instruction_id"] - if r["status"] in (qmt_repo.OS_QUEUED, qmt_repo.OS_SENDING): + if r["status"] in (qmt_repo.OS_QUEUED, qmt_repo.OS_SENDING) and not r.get('sent_at'): # 还没发出去就要撤 —— 直接本地作废, 不必跑一趟下游 await _db(qmt_repo.abort_order, iid, "发出前撤销") await _db(qmt_repo.mark_cancel_sent, iid) diff --git a/config/settings.py b/config/settings.py index 7b1adca..bae40c9 100644 --- a/config/settings.py +++ b/config/settings.py @@ -212,6 +212,7 @@ class Settings(BaseSettings): PMS_DISPATCH_MODE: str = "shadow" # 下发通道: shadow(影子,默认) / ws(直连QMT,待实现) PMS_EXEC_SLICES: int = 1 # 当日配额分几笔出手 (设计「分笔卖出配额」) PMS_ORDER_TTL_MIN: int = 10 # 单个下发分片的挂单有效期(交易分钟), 到点下游自动撤 + PMS_EXEC_QMT_DAY_ORDER: bool = False # 普通QMT限价单当日有效;微盘、网格等独立执行不受影响 # --- 卖出分桶收口与紧急直通 (2026-08-17 清仓择时改造) --- # 「现价不低于均价才卖」是只在强势时放行的条件, 下跌日全天不满足, 全部数量会 # 堆到 14:45 一笔打出。分桶: 桶内照旧择价, 桶收口无条件补齐该桶份额, 把跌日的 diff --git a/scripts/run_tests.py b/scripts/run_tests.py index 7cbb9ba..a9f4a2c 100644 --- a/scripts/run_tests.py +++ b/scripts/run_tests.py @@ -5,6 +5,7 @@ 运行: docker compose run --rm pms-web python scripts/run_tests.py 包含 (例数按 2026-10-26 隔离回归实跑校正): + test_batch52_units.py 当日限价、撤单拒绝、迟到成交、发送恢复与真实SQL状态保护 (21例) test_batch51_units.py 跨日决策复核、撤单回报、数量约束、人工确认与真实SQL事务及完整选股接线 (36例) test_batch50_units.py QMT限价等待、价格来源故障、用户暂停、配额防重和试算隔离 (14例) test_batch49_units.py 持仓分组、同名股票与批次归属、未迁移及缺数展示 (8例) @@ -182,6 +183,7 @@ import sys HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) SUITES = [ + "test_batch52_units.py", "test_batch51_units.py","test_core_units.py", "test_batch2_units.py", "test_batch3_units.py", "test_batch4_units.py", "test_batch5_units.py", "test_batch6_units.py", "test_batch7_units.py", "test_batch8_units.py", "test_batch9_units.py", diff --git a/scripts/test_batch10_units.py b/scripts/test_batch10_units.py index aaab11a..d350d45 100644 --- a/scripts/test_batch10_units.py +++ b/scripts/test_batch10_units.py @@ -50,6 +50,8 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # 这些函数**写失败时不抛异常**, 只把失败写在返回值里。调用点必须接住。 # key = 函数名, value = 允许的调用者模块名 (None = 不限, 用于 _db(f, ...) 这种间接调用) SOFT_FAIL = { + "mark_send_attempt": {"qmt_repo"}, + "request_order_cancel": {"qmt_repo"}, "process": {"daily_buy_review"}, "decide_confirmation": {"daily_buy_review"}, "compare_review_instruction": {"pms_repo"}, diff --git a/scripts/test_batch52_units.py b/scripts/test_batch52_units.py new file mode 100644 index 0000000..56f7fa0 --- /dev/null +++ b/scripts/test_batch52_units.py @@ -0,0 +1,216 @@ +"""当日限价有效期、撤单与成交交错,以及传输状态的真实SQL回归。""" +import unit_test_guard +import asyncio +import copy +import os +import sys +import tempfile +import unittest +from contextlib import nullcontext +from datetime import datetime +from unittest.mock import AsyncMock, patch +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from sqlalchemy import create_engine, text +from app.db import session +from app.repo import qmt_repo, pms_repo +from app.services import executor, dispatcher +from app.ws.runner import WsRunner + + +class ChannelTest(unittest.TestCase): + def setUp(self): + self.loop = asyncio.new_event_loop(); asyncio.set_event_loop(self.loop) + self.addCleanup(self.loop.close) + self.runner = WsRunner() + self.row = {'instruction_id': 'P_D01', 'parent_id': 'P', 'qty': 400, 'cum_qty': 0, + 'status': 'ACCEPTED', 'cancel_state': 'SENT', 'ts_code': '688100.SH'} + self.use(qmt_repo, 'get_order', side_effect=lambda _: copy.deepcopy(self.row)) + self.use(qmt_repo, 'update_order', side_effect=self.update) + + def use(self, obj, name, **kw): + p = patch.object(obj, name, **kw); m = p.start(); self.addCleanup(p.stop); return m + + def update(self, _, **fields): self.row.update(fields); return 1 + def reject(self, code='ALREADY_FINAL'): + self.loop.run_until_complete(self.runner._apply_side_effects('reject', + {'instruction_id': 'P_D01', 'code': code, 'reason': 'cancel denied'}, {})) + def state(self, status, done): + self.loop.run_until_complete(self.runner._on_order_update('P_D01', + {'status': status, 'cum_qty': done, 'final': status in qmt_repo.FINAL, 'leaves_qty': 0})) + + def test_cancel_reject_keeps_order_and_reservation(self): + self.row.update(status='PARTIAL', cum_qty=100) + self.reject('INTERNAL') + self.assertEqual((self.row['status'], self.row['cum_qty']), ('PARTIAL', 100)) + self.assertNotIn('final_at', self.row) + with patch.object(dispatcher, 'mode', return_value='ws'), patch.object(qmt_repo, 'orders_for_parent', return_value=[self.row]): + self.assertEqual(executor._parent_available({'instruction_id': 'P', 'qty': 400, 'exec_qty': 0}, []), 0) + + def test_already_final_before_final_update_keeps_pending(self): + self.row['cancel_state'] = 'NONE' + self.reject(); self.assertEqual(self.row['status'], 'ACCEPTED') + self.state('FILLED', 400); self.assertEqual(self.row['status'], 'FILLED') + + def test_reject_cannot_overwrite_filled(self): + self.row.update(status='FILLED', cum_qty=400) + self.reject(); self.assertEqual((self.row['status'], self.row['cum_qty']), ('FILLED', 400)) + + def test_genuine_place_rejection_still_finishes(self): + self.row.update(status='SENT', cancel_state='NONE') + self.reject('INVALID_PRICE'); self.assertEqual(self.row['status'], 'REJECTED') + + def test_partial_cancel_preserves_fill_releases_only_remainder(self): + self.row['cum_qty'] = 100 + self.state('CANCELLED', 100) + with patch.object(dispatcher, 'mode', return_value='ws'), patch.object(qmt_repo, 'orders_for_parent', return_value=[self.row]): + self.assertEqual(executor._parent_available({'instruction_id': 'P', 'qty': 400, 'exec_qty': 0}, []), 300) + + def test_cancel_cannot_zero_previously_reported_fills(self): + self.row.update(status='PARTIAL', cum_qty=100) + self.state('CANCELLED', 0) + self.assertEqual((self.row['status'], self.row['cum_qty']), ('PARTIAL', 100)) + self.assertEqual(self.runner._stat['order_update_conflicts'], 1) + + def test_missing_or_invalid_cumulative_quantity_keeps_pending(self): + for quantity in (None, -1, 500): + self.state('CANCELLED', quantity) + self.assertEqual(self.row['status'], 'ACCEPTED') + self.state('FILLED', 0); self.assertEqual(self.row['status'], 'ACCEPTED') + + def test_late_cancel_does_not_override_full_fill(self): + self.state('FILLED', 400); self.state('CANCELLED', 400) + self.assertEqual(self.row['status'], 'FILLED') + + def test_restarted_queued_order_is_cancelled_at_qmt(self): + self.row.update(status='QUEUED', sent_at=datetime.now(), cancel_state='REQUESTED', cancel_id='C') + with patch.object(qmt_repo, 'next_cancel_requests', return_value=[self.row]), \ + patch.object(qmt_repo, 'mark_cancel_sent'), patch.object(qmt_repo, 'abort_order') as abort, \ + patch.object(self.runner, '_send', new_callable=AsyncMock) as send: + self.loop.run_until_complete(self.runner._drain_cancels('unused')) + abort.assert_not_called(); send.assert_awaited_once() + self.assertEqual(send.call_args.args[0], 'cancel_order') + + def test_unsent_queue_can_be_aborted_locally(self): + self.row.update(status='QUEUED', sent_at=None, cancel_state='REQUESTED') + with patch.object(qmt_repo, 'next_cancel_requests', return_value=[self.row]), \ + patch.object(qmt_repo, 'mark_cancel_sent'), patch.object(qmt_repo, 'abort_order') as abort, \ + patch.object(self.runner, '_send', new_callable=AsyncMock) as send: + self.loop.run_until_complete(self.runner._drain_cancels('unused')) + abort.assert_called_once(); send.assert_not_called() + + def test_expired_uncertain_send_needs_downstream_cancel(self): + self.row.update(status='QUEUED', sent_at=datetime.now(), cancel_state='NONE') + with patch.object(qmt_repo, 'request_order_cancel', return_value=1) as cancel, patch.object(qmt_repo, 'abort_order') as abort: + self.loop.run_until_complete(self.runner._stop_outbox_order('P_D01', 'expired')) + cancel.assert_called_once(); abort.assert_not_called() + + def test_cancel_between_claim_and_send_prevents_transport(self): + from app.services import execution_conflicts + self.row.update(status='SENDING', cancel_state='NONE', side='buy', limit_price=23.3, + valid_until=9999999999999) + with patch.object(qmt_repo, 'next_queued', return_value=[self.row]), \ + patch.object(qmt_repo, 'claim_order', return_value=True), \ + patch.object(execution_conflicts, 'queued_buy_blocker', return_value=None), \ + patch.object(qmt_repo, 'mark_send_attempt', return_value=False), \ + patch.object(self.runner, '_send', new_callable=AsyncMock) as send: + self.loop.run_until_complete(self.runner._drain_outbox('unused')) + send.assert_not_called() + + def test_send_error_after_attempt_keeps_uncertain_order_retryable(self): + from app.services import execution_conflicts + self.row.update(status='SENDING', cancel_state='NONE', side='buy', limit_price=23.3, + valid_until=9999999999999) + def attempted(_): self.row['sent_at'] = datetime.now(); return True + with patch.object(qmt_repo, 'next_queued', return_value=[self.row]), \ + patch.object(qmt_repo, 'claim_order', return_value=True), \ + patch.object(execution_conflicts, 'queued_buy_blocker', return_value=None), \ + patch.object(qmt_repo, 'mark_send_attempt', side_effect=attempted), \ + patch.object(qmt_repo, 'requeue_order') as requeue, \ + patch.object(self.runner, '_send', new_callable=AsyncMock, side_effect=RuntimeError('uncertain send')): + with self.assertRaises(RuntimeError): + self.loop.run_until_complete(self.runner._drain_outbox('unused')) + self.assertTrue(self.row['sent_at']) + self.assertFalse(requeue.call_args.args[-1]) + + +class DeadlineTest(unittest.TestCase): + def test_qmt_day_order_always_ends_at_close(self): + with patch.object(executor.param_store, 'get_bool', return_value=True): + for hour, minute in [(9, 31), (11, 25), (14, 58)]: + self.assertEqual(executor.order_deadline(datetime(2026, 10, 30, hour, minute), + {'qmt_price_monitor': True}, ttl_min=10), 900) + + def test_old_mode_keeps_ten_minute_lifetime(self): + now = datetime(2026, 10, 30, 10, 22) + with patch.object(executor.param_store, 'get_bool', return_value=False): + self.assertEqual(executor.order_deadline(now, {'qmt_price_monitor': True}, ttl_min=10), 632) + with patch.object(executor.param_store, 'get_bool', return_value=True): + self.assertEqual(executor.order_deadline(now, {}, ttl_min=10), 632) + + def test_repeated_cancel_request_reports_pending(self): + with patch.object(dispatcher, 'mode', return_value='ws'), \ + patch.object(qmt_repo, 'request_cancel', return_value=0), \ + patch.object(qmt_repo, 'orders_for_parent', return_value=[{'status': 'PARTIAL', 'cancel_state': 'SENT'}]): + result = dispatcher.cancel(instruction_id='P') + self.assertTrue(result['ok']); self.assertTrue(result['cancel_pending']) + + +class SqlTest(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(); self.addCleanup(self.tmp.cleanup) + self.engine = create_engine('sqlite:///' + self.tmp.name + '/orders.sqlite'); self.addCleanup(self.engine.dispose) + for obj, name, kwargs in [(session, 'get_engine', {'return_value': self.engine}), (session, '_check_cooldown', {})]: + p = patch.object(obj, name, **kwargs); p.start(); self.addCleanup(p.stop) + with self.engine.begin() as c: + c.execute(text('CREATE TABLE pms_qmt_order(instruction_id TEXT PRIMARY KEY,status TEXT,sent_at TEXT,updated_at TEXT,send_attempts INTEGER,cancel_state TEXT,reject_code TEXT,reject_reason TEXT,final_at TEXT)')) + c.execute(text("INSERT INTO pms_qmt_order(instruction_id,status,send_attempts,cancel_state) VALUES('I','SENDING',0,'NONE')")) + def row(self): return session.fetch_one("SELECT * FROM pms_qmt_order WHERE instruction_id='I'") + + def test_send_marker_persists_before_transport(self): + self.assertTrue(qmt_repo.mark_send_attempt('I')); self.assertTrue(self.row()['sent_at']) + self.assertEqual(qmt_repo.abort_order('I', 'cancel'), 0) + self.assertEqual(self.row()['status'], 'SENDING') + + def test_cancel_wins_before_transport(self): + qmt_repo.update_order('I', cancel_state='REQUESTED') + self.assertFalse(qmt_repo.mark_send_attempt('I')) + self.assertEqual(qmt_repo.abort_order('I', 'cancel'), 1) + self.assertEqual(self.row()['status'], 'ABORTED') + + def test_fast_ack_or_fill_never_regresses_to_sent(self): + for status in ('ACCEPTED', 'PARTIAL', 'FILLED', 'CANCELLED'): + qmt_repo.update_order('I', status=status) + qmt_repo.mark_sent('I'); self.assertEqual(self.row()['status'], status) + qmt_repo.requeue_order('I', 'error'); self.assertEqual(self.row()['status'], status) + + def test_restart_retains_send_uncertainty(self): + qmt_repo.mark_send_attempt('I'); qmt_repo.reset_stuck_sending() + self.assertEqual(self.row()['status'], 'QUEUED'); self.assertTrue(self.row()['sent_at']) + self.assertEqual(qmt_repo.abort_order('I', 'expired'), 0) + + +class ZBookTest(unittest.TestCase): + def test_late_trade_after_parent_cancel_books_once_in_own_strategy(self): + from test_wiring import install_fakes + from app.services import rotation_execution as re, rotation_accounting as ra + from app.repo import rotation_repo + fake = install_fakes(prices={'688100.SH': 23.3}) + fake.insert_instruction(instruction_id='P', origin_type='proposal', origin_id='X', + ts_code='688100.SH', action='OPEN', side='buy', qty=400, status='CANCELLED') + fake.instructions['P']['book_id'] = 'original' + fake.qmt.put_trade(seq=1, instruction_id='P_D01', ts_code='688100.SH', side='buy', qty=100, price=23.3) + act = {'instruction_id': 'P', 'kind': 'BUY', 'ts_code': '688100.SH', 'qty': 100, 'price': 23.3, 'lot_type': 'BASE', 'order_id': 'T1'} + with patch.object(re.db, 'transaction', side_effect=nullcontext), \ + patch.object(rotation_repo, 'account_guard', side_effect=nullcontext), \ + patch.object(re.db, 'fetch_one', side_effect=lambda *a, **kw: {'processed': fake.qmt.inbox[1]['processed']}), \ + patch.object(pms_repo, 'get_instruction', side_effect=lambda iid: copy.deepcopy(fake.instructions.get(iid))), \ + patch.object(ra, 'record_fill') as cash: + self.assertTrue(re.book_trade(act, [], 1)) + self.assertFalse(re.book_trade(act, [], 1)) + self.assertEqual(fake.positions['688100.SH']['total_qty'], 100) + self.assertEqual(fake.instructions['P']['exec_qty'], 100) + self.assertEqual(fake.instructions['P']['status'], 'CANCELLED') + cash.assert_called_once_with('original', 'buy', 2330., 0, '1') + + +if __name__ == '__main__': unittest.main()