341 lines
17 KiB
Python
341 lines
17 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""任务命令结算按方案额 (2026-10-08)。后端离线单测, 不连库。
|
||
|
||
由来: 建仓 / 升仓 / 个股减仓这类任务命令, 方案全部成交也到不了 DONE。命令目标
|
||
(progress.target_amount) 是「规模 × 比例 − 现有市值」的理论金额, 没取整到手; 方案是整手的,
|
||
方案额几乎总比目标少一截零头。结算拿理论目标当完成线, 一股不差地成交完也够不着 ——
|
||
命令一直挂在执行中、窗口末转部分完成, 同股重下被判重复、暂停买入与一键清仓报冲突。
|
||
开发机实算: 现价 10.37 建仓 6% × 100 万, 目标 60,000、方案 59,109, 全部成交仍差 891 元。
|
||
|
||
修法: 结算线 = min(目标, 方案额) − 未解锁 GATED 批金额 (command_spec.effective_target)。
|
||
这里测三块:
|
||
A effective_target 纯逻辑: 取整零头、方案额高于目标、GATED 扣减与边界。
|
||
B 方案生成接结算: plan_open_target / plan_reduce_stock 产出的方案全部成交即判 DONE。
|
||
C 服务层 refresh_progress (内存桩): 建仓端到端与同股重下、HALT 行不进方案额、
|
||
方案没凑够目标的口径、没成交完的照旧不放过。
|
||
"""
|
||
import unit_test_guard # noqa: F401，单独运行也禁止联网
|
||
import os
|
||
import sys
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||
|
||
from app.core import command_spec as cs # noqa: E402
|
||
from app.core import planner as pl # noqa: E402
|
||
|
||
RESULTS = []
|
||
|
||
PX = 10.37 # 开发机实算用的现价
|
||
SCALE = 1_000_000.0
|
||
|
||
|
||
def case(name):
|
||
def deco(fn):
|
||
RESULTS.append((name, fn))
|
||
return fn
|
||
return deco
|
||
|
||
|
||
def _ctx(**kw):
|
||
"""plan_open_target 的组合上下文: 空仓、上限宽松, 只让取整这一件事起作用。"""
|
||
c = {"scale": SCALE, "portfolio_cap": 0.60, "stock_cap": 0.08, "max_names": 15,
|
||
"portfolio_mv": 0.0, "names_count": 0, "stock_mv": 0.0, "is_new_name": True,
|
||
"sector": None}
|
||
c.update(kw)
|
||
return c
|
||
|
||
|
||
def _settle(target, items, filled_ratio=1.0, window_over=False):
|
||
"""把方案条目当作非 GATED 批按比例成交, 走一遍与 refresh_progress 相同的结算口径。"""
|
||
planned = sum(i["amount"] for i in items if i["action"] != pl.A_HALT)
|
||
gated = sum(i["amount"] for i in items if i.get("gated"))
|
||
done = sum(i["amount"] * filled_ratio for i in items
|
||
if not i.get("gated") and i["action"] != pl.A_HALT)
|
||
return cs.settle_task_status(cs.effective_target(target, planned, gated), done, window_over)
|
||
|
||
|
||
# ================================================================ A 纯逻辑
|
||
@case("A1 一手取整零头: 目标 60,000、方案 59,109 全部成交 → 判 DONE (旧口径永远够不着)")
|
||
def _():
|
||
eff = cs.effective_target(60_000.0, 59_109.0, 0.0)
|
||
assert abs(eff - 59_109.0) < 1e-9, eff
|
||
assert cs.settle_task_status(eff, 59_109.0, False) == cs.ST_DONE
|
||
# 钉住由来: 旧口径拿理论目标当线, 全部成交仍差 891 元, 窗口内执行中、窗口后部分完成
|
||
assert cs.settle_task_status(60_000.0, 59_109.0, False) == cs.ST_EXECUTING
|
||
assert cs.settle_task_status(60_000.0, 59_109.0, True) == cs.ST_PARTIAL
|
||
|
||
|
||
@case("A2 方案额高于目标 (清弱票整票卖、升仓取整微超): 结算线仍是目标, 没够目标不判 DONE")
|
||
def _():
|
||
eff = cs.effective_target(200_000.0, 201_500.0, 0.0)
|
||
assert eff == 200_000.0, eff
|
||
assert cs.settle_task_status(eff, 150_000.0, False) == cs.ST_EXECUTING
|
||
assert cs.settle_task_status(eff, 200_000.0, False) == cs.ST_DONE
|
||
|
||
|
||
@case("A3 GATED 扣减口径不变; 结算线不为负; 空值按 0")
|
||
def _():
|
||
# 三批建仓: 方案 58,072 里 FILL/ADD 两批 29,036 是 GATED → 结算线 = 首批 29,036
|
||
assert abs(cs.effective_target(60_000.0, 58_072.0, 29_036.0) - 29_036.0) < 1e-9
|
||
assert cs.effective_target(10_000.0, 5_000.0, 8_000.0) == 0.0
|
||
assert cs.effective_target(None, None) == 0.0
|
||
assert cs.effective_target(50_000.0, None) == 50_000.0
|
||
|
||
|
||
# ================================================================ B 方案生成接结算
|
||
@case("B1 建仓 10.37 元 × 6%: 单批与 50/25/25 两种拆法, 首批全部成交都判 DONE; 没成交完不放过")
|
||
def _():
|
||
one = pl.plan_open_target(ts_code="600000.SH", target_pct=0.06, price=PX, ctx=_ctx(),
|
||
params={"batch_split": (1.0,)})
|
||
assert one["target_amount"] == 60_000.0 and one["planned_amount"] == 59_109.0, one
|
||
assert len(one["items"]) == 1 and one["items"][0]["qty"] == 5_700, one["items"]
|
||
|
||
three = pl.plan_open_target(ts_code="600000.SH", target_pct=0.06, price=PX, ctx=_ctx(),
|
||
params={"batch_split": (0.5, 0.25, 0.25)})
|
||
assert [i["qty"] for i in three["items"]] == [2_800, 1_400, 1_400], three["items"]
|
||
assert [bool(i.get("gated")) for i in three["items"]] == [False, True, True]
|
||
|
||
for r in (one, three):
|
||
assert _settle(r["target_amount"], r["items"]) == cs.ST_DONE, r
|
||
assert _settle(r["target_amount"], r["items"], filled_ratio=0.9) == cs.ST_EXECUTING
|
||
assert _settle(r["target_amount"], r["items"], filled_ratio=0.9,
|
||
window_over=True) == cs.ST_PARTIAL
|
||
|
||
|
||
@case("B2 个股减至 5%: 持 10,000 股 @10.37, 超出 53,700 → 方案 5,100 股 52,887, 全部成交判 DONE")
|
||
def _():
|
||
r = pl.plan_reduce_stock(ts_code="600000.SH", target_pct=0.05,
|
||
position={"total_qty": 10_000, "price": PX}, scale=SCALE)
|
||
assert abs(r["target_amount"] - 53_700.0) < 1e-6, r
|
||
assert r["items"][0]["qty"] == 5_100 and abs(r["planned_amount"] - 52_887.0) < 1e-6, r
|
||
assert _settle(r["target_amount"], r["items"]) == cs.ST_DONE
|
||
assert _settle(r["target_amount"], r["items"], filled_ratio=0.98) == cs.ST_EXECUTING
|
||
|
||
|
||
# ================================================================ C 服务层
|
||
def _fill(fake, plans):
|
||
for p in plans:
|
||
fake.update_plan(p["plan_id"], status="DONE", filled_qty=p["qty"])
|
||
|
||
|
||
@case("C1 建仓端到端 (50/25/25): 首批成交完即 DONE、GATED 批照记; 结算前同股重下判重复, 结算后放行")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as csvc
|
||
fake = install_fakes(prices={"600000.SH": PX}, params={"PMS_TOTAL_SCALE": str(int(SCALE))})
|
||
r = csvc.issue("OPEN_TARGET", {"ts_code": "600000.SH", "target_pct": "6%"})
|
||
assert r["ok"] and r["status"] == "EXECUTING", r
|
||
cid = r["command_id"]
|
||
plans = fake.list_plans(command_id=cid)
|
||
base = [p for p in plans if p["status"] == "PENDING"]
|
||
assert len(base) == 1 and base[0]["qty"] == 2_800, plans
|
||
|
||
csvc.refresh_progress(cid)
|
||
assert fake.commands[cid]["status"] == "EXECUTING", fake.commands[cid]
|
||
dup = csvc.issue("OPEN_TARGET", {"ts_code": "600000.SH", "target_pct": "6%"})
|
||
assert not dup["ok"] and any("重复下达" in c["reason"] for c in dup["conflicts"]), dup
|
||
|
||
_fill(fake, base)
|
||
csvc.refresh_progress(cid)
|
||
c = fake.commands[cid]
|
||
assert c["status"] == "DONE", c
|
||
# 页面照实显示: 目标仍是 60,000, 已成交 29,036, GATED 两批 29,036 单列
|
||
assert c["progress"]["target_amount"] == 60_000.0, c["progress"]
|
||
assert abs(c["progress"]["done_amount"] - 29_036.0) < 1e-6, c["progress"]
|
||
assert abs(c["progress"]["gated_amount"] - 29_036.0) < 1e-6, c["progress"]
|
||
assert [p["status"] for p in fake.list_plans(command_id=cid)] == ["DONE", "CANCELLED", "CANCELLED"]
|
||
again = csvc.issue("OPEN_TARGET", {"ts_code": "600000.SH", "target_pct": "6%"})
|
||
assert again["ok"] and not again.get("conflicts"), again
|
||
|
||
|
||
@case("C2 建仓单批 (开发机实算口径): 方案 59,109 全部成交 → DONE, 进度照记目标 60,000")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as csvc
|
||
fake = install_fakes(prices={"600000.SH": PX},
|
||
params={"PMS_TOTAL_SCALE": str(int(SCALE)), "PMS_BATCH_SPLIT": "1.0"})
|
||
r = csvc.issue("OPEN_TARGET", {"ts_code": "600000.SH", "target_pct": "6%"})
|
||
assert r["ok"], r
|
||
cid = r["command_id"]
|
||
plans = fake.list_plans(command_id=cid)
|
||
assert len(plans) == 1 and plans[0]["qty"] == 5_700, plans
|
||
_fill(fake, plans)
|
||
out = csvc.refresh_progress(cid)
|
||
assert out["commands"][0]["status"] == "DONE", out
|
||
prog = fake.commands[cid]["progress"]
|
||
assert prog["target_amount"] == 60_000.0 and abs(prog["done_amount"] - 59_109.0) < 1e-6, prog
|
||
|
||
|
||
@case("C3 撤单 HALT 行不进方案额: 降仓顺手撤的在途买单金额再大, 卖出方案成交完即 DONE")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as csvc
|
||
fake = install_fakes(params={"PMS_TOTAL_SCALE": str(int(SCALE))})
|
||
fake.insert_command(command_id="CMD_H1", cmd_class=cs.CLS_TASK, cmd_type="REDUCE_EXPOSURE",
|
||
ts_code=None, params={}, status="EXECUTING",
|
||
progress={"target_amount": 50_000.0, "planned_amount": 49_800.0,
|
||
"deadline": "2099-01-01"})
|
||
fake.insert_plans([
|
||
{"plan_id": "PL_H1", "command_id": "CMD_H1", "ts_code": "000001.SZ", "action": "HALT",
|
||
"qty": 8_000, "amount": 80_000.0, "status": "DONE", "filled_qty": 0,
|
||
"priority": 10, "deadline": "2099-01-01"},
|
||
{"plan_id": "PL_H2", "command_id": "CMD_H1", "ts_code": "600000.SH", "action": "TRIM",
|
||
"qty": 4_800, "amount": 49_800.0, "status": "DONE", "filled_qty": 4_800,
|
||
"priority": 30, "deadline": "2099-01-01"},
|
||
])
|
||
csvc.refresh_progress("CMD_H1")
|
||
# HALT 行若算进方案额: min(50,000, 129,800) = 50,000 > 49,800, 又卡住
|
||
assert fake.commands["CMD_H1"]["status"] == "DONE", fake.commands["CMD_H1"]
|
||
|
||
|
||
@case("C4 方案本身没凑够目标 (升仓候选不够): 方案全部成交判 DONE, 缺口原样留在进度里")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as csvc
|
||
fake = install_fakes(params={"PMS_TOTAL_SCALE": str(int(SCALE))})
|
||
fake.insert_command(command_id="CMD_S1", cmd_class=cs.CLS_TASK,
|
||
cmd_type="INCREASE_EXPOSURE", ts_code=None, params={},
|
||
status="EXECUTING",
|
||
progress={"target_amount": 200_000.0, "planned_amount": 120_000.0,
|
||
"gap": 80_000.0, "deadline": "2099-01-01"})
|
||
fake.insert_plans([
|
||
{"plan_id": "PL_S1", "command_id": "CMD_S1", "ts_code": "600000.SH", "action": "OPEN",
|
||
"qty": 12_000, "amount": 120_000.0, "status": "DONE", "filled_qty": 12_000,
|
||
"priority": 10, "deadline": "2099-01-01"},
|
||
])
|
||
csvc.refresh_progress("CMD_S1")
|
||
c = fake.commands["CMD_S1"]
|
||
assert c["status"] == "DONE", c
|
||
assert c["progress"]["gap"] == 80_000.0 and c["progress"]["target_amount"] == 200_000.0, c
|
||
# 降仓可卖不够那一侧的方案注记同步改口: 不再承诺「置部分完成」
|
||
r = pl.plan_reduce_exposure(release_amount=10_000_000, positions=[
|
||
{"ts_code": "600000.SH", "price": 10.0, "total_qty": 1_000, "base_qty": 1_000,
|
||
"cushion_pct": 0.05, "neg_cushion_days": 0}])
|
||
gap_note = [n for n in r["notes"] if "可减持仓不足" in n]
|
||
assert gap_note and "部分完成" not in gap_note[0] and "缺口" in gap_note[0], r["notes"]
|
||
|
||
|
||
@case("C5 没成交完的照旧不放过: 成交一半窗口内 EXECUTING、窗口过后 PARTIAL; 有未出清方案不判 DONE")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as csvc
|
||
fake = install_fakes(params={"PMS_TOTAL_SCALE": str(int(SCALE))})
|
||
for cid, dl in (("CMD_P1", "2099-01-01"), ("CMD_P2", "2000-01-01")):
|
||
fake.insert_command(command_id=cid, cmd_class=cs.CLS_TASK, cmd_type="OPEN_TARGET",
|
||
ts_code="600000.SH", params={}, status="EXECUTING",
|
||
progress={"target_amount": 60_000.0, "deadline": dl})
|
||
fake.insert_plans([
|
||
{"plan_id": f"PL_{cid}", "command_id": cid, "ts_code": "600000.SH",
|
||
"action": "OPEN", "qty": 5_700, "amount": 59_109.0, "status": "EXECUTING",
|
||
"filled_qty": 2_800, "priority": 10, "deadline": dl}])
|
||
csvc.refresh_progress("CMD_P1")
|
||
csvc.refresh_progress("CMD_P2")
|
||
assert fake.commands["CMD_P1"]["status"] == "EXECUTING", fake.commands["CMD_P1"]
|
||
assert fake.commands["CMD_P2"]["status"] == "PARTIAL", fake.commands["CMD_P2"]
|
||
# 金额都到了但还有一条 0 金额方案没出清 (取不到现价的整票卖单) → 不判 DONE
|
||
fake.insert_command(command_id="CMD_P3", cmd_class=cs.CLS_TASK, cmd_type="EXIT_STOCK",
|
||
ts_code="600000.SH", params={}, status="EXECUTING",
|
||
progress={"target_amount": 30_000.0, "deadline": "2099-01-01"})
|
||
fake.insert_plans([
|
||
{"plan_id": "PL_P3a", "command_id": "CMD_P3", "ts_code": "600000.SH", "action": "EXIT",
|
||
"qty": 3_000, "amount": 30_000.0, "status": "DONE", "filled_qty": 3_000,
|
||
"priority": 20, "deadline": "2099-01-01"},
|
||
{"plan_id": "PL_P3b", "command_id": "CMD_P3", "ts_code": "000001.SZ", "action": "EXIT",
|
||
"qty": 1_000, "amount": 0.0, "status": "PENDING", "filled_qty": 0,
|
||
"priority": 20, "deadline": "2099-01-01"}])
|
||
csvc.refresh_progress("CMD_P3")
|
||
assert fake.commands["CMD_P3"]["status"] == "EXECUTING", fake.commands["CMD_P3"]
|
||
|
||
|
||
@case("C6 非零目标但方案为空不判完成")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.services import command_service as svc
|
||
fake = install_fakes()
|
||
fake.insert_command(command_id="EMPTY", cmd_class=cs.CLS_TASK, cmd_type="OPEN_TARGET",
|
||
ts_code="600000.SH", params={}, status="EXECUTING",
|
||
progress={"target_amount": 60_000, "deadline": "2099-01-01"})
|
||
svc.refresh_progress("EMPTY")
|
||
assert fake.commands["EMPTY"]["status"] == "EXECUTING"
|
||
|
||
|
||
@case("C7 完成清理失败不置 DONE，取消成功后进程失败仍可重试")
|
||
def _():
|
||
from test_wiring import install_fakes
|
||
from app.repo import pms_repo
|
||
from app.services import command_service as svc
|
||
for stage in ("save", "cancel", "final"):
|
||
fake = install_fakes(prices={"600000.SH": PX}, params={"PMS_TOTAL_SCALE": str(int(SCALE))})
|
||
cmd = svc.issue("OPEN_TARGET", {"ts_code": "600000.SH", "target_pct": "6%"})
|
||
cid = cmd["command_id"]
|
||
_fill(fake, fake.list_plans(command_id=cid, statuses=["PENDING"]))
|
||
update, cancel = pms_repo.update_command, pms_repo.cancel_gated_plans_of_command
|
||
def broken_update(cid, **kw):
|
||
if (stage == "save" and kw.get("status") is None) or (stage == "final" and kw.get("status") == "DONE"):
|
||
return 0
|
||
return update(cid, **kw)
|
||
try:
|
||
pms_repo.update_command = broken_update
|
||
if stage == "cancel":
|
||
pms_repo.cancel_gated_plans_of_command = lambda cid: 0
|
||
try:
|
||
svc.refresh_progress(cid)
|
||
raise AssertionError("结算写入失败必须报错")
|
||
except RuntimeError:
|
||
pass
|
||
assert fake.commands[cid]["status"] == "EXECUTING"
|
||
if stage in ("save", "cancel"):
|
||
assert len(fake.list_plans(command_id=cid, statuses=["GATED"])) == 2
|
||
finally:
|
||
pms_repo.update_command, pms_repo.cancel_gated_plans_of_command = update, cancel
|
||
svc.refresh_progress(cid)
|
||
assert fake.commands[cid]["status"] == "DONE"
|
||
assert not fake.list_plans(command_id=cid, statuses=["GATED"])
|
||
assert fake.commands[cid]["progress"]["settlement_gated_amount"] == 29_036.0
|
||
|
||
|
||
@case("C8 只取消本命令 GATED，不改在途与其他命令；真实 SQL 限定同一范围")
|
||
def _():
|
||
import importlib.util
|
||
from pathlib import Path
|
||
from test_wiring import install_fakes
|
||
fake = install_fakes()
|
||
for i, (cid, status) in enumerate([("A", "GATED"), ("A", "EXECUTING"), ("A", "PENDING"), ("B", "GATED")]):
|
||
fake.insert_plans([{"plan_id": str(i), "command_id": cid, "status": status}])
|
||
assert fake.cancel_gated_plans_of_command("A") == 1
|
||
assert [p["status"] for p in fake.plans] == ["CANCELLED", "EXECUTING", "PENDING", "GATED"]
|
||
path = Path(__file__).resolve().parents[1] / "app/repo/pms_repo.py"
|
||
spec = importlib.util.spec_from_file_location("repo_sql_check", path)
|
||
repo = importlib.util.module_from_spec(spec)
|
||
spec.loader.exec_module(repo)
|
||
calls = []
|
||
repo.execute = lambda sql, params: calls.append((sql, params)) or 1
|
||
assert repo.cancel_gated_plans_of_command("A") == 1
|
||
sql, params = calls[0]
|
||
from app.db.session import assert_single_table
|
||
assert_single_table(sql)
|
||
assert "WHERE command_id = :cid AND status = 'GATED'" in sql and params["cid"] == "A"
|
||
|
||
|
||
def main():
|
||
ok = 0
|
||
for name, fn in RESULTS:
|
||
try:
|
||
fn()
|
||
ok += 1
|
||
print(" ok " + name)
|
||
except Exception:
|
||
import traceback
|
||
print(" FAIL " + name)
|
||
traceback.print_exc()
|
||
print("-" * 60)
|
||
if ok == len(RESULTS):
|
||
print("ALL PASS (%d cases)" % ok)
|
||
return 0
|
||
print("FAILED %d/%d" % (len(RESULTS) - ok, len(RESULTS)))
|
||
return 1
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|