yumoqing/pbl_runtime_ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

deliver: 交付收口（引擎代为提交）

Browse Source
This commit is contained in:
agent.develop 2026-09-21 11:52:57 +08:00
parent 9f99f60315
commit f29158a541
9 changed files with 670 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.m11b2c_tmp/pytest_run1.txt Normal file
View File

@ -0,0 +1,12 @@
=== CMD: .venv/bin/python -m pytest tests/ -v --tb=short ===
=== CWD: /d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext ===
=== DATE: 2026-09-21T11:23:05+08:00 ===
============================= test session starts ==============================
platform linux -- Python 3.10.12, pytest-9.1.1, pluggy-1.6.0 -- /d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/.venv/bin/python
cachedir: .pytest_cache
rootdir: /d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext
configfile: pyproject.toml
collecting ... collected 0 items
============================ no tests ran in 0.01s =============================
=== EXIT_CODE=5 ===

18
.m11b2c_tmp/selftest2.err Normal file
View File

@ -0,0 +1,18 @@
Traceback (most recent call last):
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 555, in <module>
sys.exit(main())
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 542, in main
suite_memory()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 473, in suite_memory
asyncio.new_event_loop().run_until_complete(run())
File "/usr/lib/python3.10/asyncio/base_events.py", line 649, in run_until_complete
return future.result()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 389, in run
await wtx.apply_runtime_event(
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 338, in apply_runtime_event
st = await _apply_state(tx, tenant_id, session_id, upd, seq_no,
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 253, in _apply_state
vals = build_row(STATE_TABLE, {
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 128, in build_row
raise rtx_db.RtxError("PBL-RTX-0004",
pbl_runtime_ext.rtx_db.RtxError: [PBL-RTX-0004] pbl_entity_state 缺少 NOT NULL 列 ['tenant_id', 'session_id', 'entity_id', 'created_at']

89
.m11b2c_tmp/selftest2.out Normal file
View File

@ -0,0 +1,89 @@
--- A. 离线单元 ---
partitions | partitions PASS：跨年命名 ['p202611', 'p202612', PASS partitions PASS：跨年命名 ['p202611', 'p202612', 'p202701', 'p202702']
partitions | partitions PASS：下月边界 2027-01-01 PASS partitions PASS：下月边界 2027-01-01
partitions | partitions PASS：已存在分区 skip、缺失分区 add PASS partitions PASS：已存在分区 skip、缺失分区 add
partitions | partitions PASS：DDL ALTER TABLE pbl_runtime PASS partitions PASS：DDL ALTER TABLE pbl_runtime_event ADD PARTITION (PARTITION p202602 VALUES LESS THAN (DATE'2026-03-01'))
partitions | partitions.self_check PASS PASS partitions.self_check PASS
partitions.self_check 整体 PASS
broadcast | broadcast PASS：after_cursor=4 只回 1 条 PASS broadcast PASS：after_cursor=4 只回 1 条
broadcast | broadcast PASS：环形缓冲溢出报 truncated=True PASS broadcast PASS：环形缓冲溢出报 truncated=True
broadcast | broadcast PASS：通道按 tenant.world 隔离 PASS broadcast PASS：通道按 tenant.world 隔离
broadcast | broadcast PASS：订阅者扇出成功 PASS broadcast PASS：订阅者扇出成功
broadcast | broadcast PASS：stats published=6 p95=0.018ms PASS broadcast PASS：stats published=6 p95=0.018ms 越界=0
broadcast | broadcast PASS：通道命名 pbl.world.7.1 PASS broadcast PASS：通道命名 pbl.world.7.1
broadcast | broadcast.self_check PASS PASS broadcast.self_check PASS
broadcast.self_check 整体 PASS
latency | latency PASS：裁决 120ms ≤ 200ms 未越界 PASS latency PASS：裁决 120ms ≤ 200ms 未越界
latency | latency PASS：裁决 450ms > 200ms 记越界 PASS latency PASS：裁决 450ms > 200ms 记越界
latency | latency PASS：summary avg=285.0 p95=450.0 breac PASS latency PASS：summary avg=285.0 p95=450.0 breaches=1
latency | latency PASS：轮询兜底 3000ms 已配置 PASS latency PASS：轮询兜底 3000ms 已配置
latency | latency PASS：p95=10 PASS latency PASS：p95=10
latency | latency PASS：Timer 实测 5.1ms PASS latency PASS：Timer 实测 5.1ms
latency | latency.self_check PASS PASS latency.self_check PASS
latency.self_check 整体 PASS
tx_write | tx_write PASS：幂等键同参同键、异参异键、≤32 字符（bebdba41666 PASS tx_write PASS：幂等键同参同键、异参异键、≤32 字符（bebdba416666…）
tx_write | tx_write PASS：client_event_id 原样透传（重放同键） PASS tx_write PASS：client_event_id 原样透传（重放同键）
tx_write | tx_write PASS：pbl_runtime_event 禁 UPDATE/DELE PASS tx_write PASS：pbl_runtime_event 禁 UPDATE/DELETE/TRUNCATE
tx_write | tx_write PASS：基表写保护生效（world 等 6 张） PASS tx_write PASS：基表写保护生效（world 等 6 张）
tx_write | tx_write PASS：pbl_runtime_event 用到的 13 列与 mod PASS tx_write PASS：pbl_runtime_event 用到的 13 列与 models 定义一致
tx_write | tx_write PASS：pbl_entity_state 用到的 9 列与 model PASS tx_write PASS：pbl_entity_state 用到的 9 列与 models 定义一致
tx_write | tx_write PASS：pbl_world_state_snapshot 用到的 9 PASS tx_write PASS：pbl_world_state_snapshot 用到的 9 列与 models 定义一致
tx_write | tx_write PASS：3 协程契约 + 1 同步守卫签名正确 PASS tx_write PASS：3 协程契约 + 1 同步守卫签名正确
tx_write | probe| PASS P1 正常写入（事件+2状态+快照）单事务提交：stmt=8 事件 PASS probe| PASS P1 正常写入（事件+2状态+快照）单事务提交：stmt=8 事件行=1 状态行=2 快照行=1 广播在commit后=True 占位符违规=0
tx_write | probe| PASS P2 幂等重放：dedup=True 事件行数=1 广播次数=0（ PASS probe| PASS P2 幂等重放：dedup=True 事件行数=1 广播次数=0（重放不重复写、不重复广播）
tx_write | probe| PASS P3 乐观锁冲突回滚：错误码=PBL-STATE-CONFLICT PASS probe| PASS P3 乐观锁冲突回滚：错误码=PBL-STATE-CONFLICT commit=-1 rollback=5 事件行残留=0 广播=0
tx_write | probe| PASS P4 中途故障原子性：抛出=RuntimeError rollba PASS probe| PASS P4 中途故障原子性：抛出=RuntimeError rollback=5 已提交事件行=0 已提交状态行=0 广播=0
tx_write | probe| PASS P5 append-only：UPDATE/DELETE/TRUN PASS probe| PASS P5 append-only：UPDATE/DELETE/TRUNCATE 被代码守卫拦截=True 引擎兜底拦截=True
tx_write | probe| PASS P6 占位符/参数数门禁生效：'SELECT 1'+2参数 被拒（ PASS probe| PASS P6 占位符/参数数门禁生效：'SELECT 1'+2参数 被拒（错误码=PBL-RTX-0005）
tx_write | probe| PASS P7 契约三处同步：6/6 对齐 PASS probe| PASS P7 契约三处同步：6/6 对齐
tx_write | probe| m11b_probe PASS：7 项探针（state_updates 非空 PASS probe| m11b_probe PASS：7 项探针（state_updates 非空端到端 P1~P4 + 守卫 P5 + 门禁有效性 P6 + 三处同步 P7）
tx_write | tx_write.self_check PASS PASS tx_write.self_check PASS
tx_write.self_check 整体 PASS
m11b_api | m11b_api PASS：5 个协程契约齐备 PASS m11b_api PASS：5 个协程契约齐备
m11b_api | m11b_api PASS：assert_append_only 同步守卫可调用 PASS m11b_api PASS：assert_append_only 同步守卫可调用
m11b_api | m11b_api PASS：contracts 清单 8 项与注册表一致 PASS m11b_api PASS：contracts 清单 8 项与注册表一致
m11b_api | m11b_api.self_check PASS PASS m11b_api.self_check PASS
m11b_api.self_check 整体 PASS
rtx_db | rtx_db PASS：仅用 sor.C/U/R/sqlExe + sqlorContext PASS rtx_db PASS：仅用 sor.C/U/R/sqlExe + sqlorContext（无模块级猜测签名）
rtx_db | rtx_db PASS：事务原语探测 sor/conn/sql 三级 PASS rtx_db PASS：事务原语探测 sor/conn/sql 三级
rtx_db | rtx_db PASS：无 begin/commit/rollback → 探测返回 Non PASS rtx_db PASS：无 begin/commit/rollback → 探测返回 None（上层抛 PBL-RTX-0002）
rtx_db | rtx_db PASS：库名不可得即抛 PBL-RTX-0001（不猜默认库） PASS rtx_db PASS：库名不可得即抛 PBL-RTX-0001（不猜默认库）
rtx_db.self_check 整体 PASS
A[三处同步] apply_runtime_event PASS impl=True export=True register=True
A[三处同步] poll_events PASS impl=True export=True register=True
A[三处同步] read_states PASS impl=True export=True register=True
A[三处同步] assert_append_only PASS impl=True export=True register=True
A[三处同步] pbl_runtime_broadcast_pull PASS impl=True export=True register=True
A[三处同步] pbl_runtime_broadcast_stats PASS impl=True export=True register=True
A[包出口可导入] pbl_runtime_broadcast_pull PASS
A[包出口可导入] pbl_runtime_broadcast_stats PASS
A[包出口可导入] apply_runtime_event PASS
A[包出口可导入] poll_events PASS
A[包出口可导入] read_states PASS
A[包出口可导入] assert_append_only PASS
A[M11b 注册清单完整（fail-closed 门禁）] PASS missing=[] total=12
A[M11a 注册清单完整] PASS total=6
--- B. 内存事务引擎端到端（真实 apply_runtime_event 主链路）---
B1[正常写入] ok 且非幂等命中 PASS seq_no=1 event_id=1
B1[正常写入] 事件表 1 行 PASS
B1[正常写入] 状态表 1 行 v1 PASS
B1[正常写入] 快照表 1 行 PASS
B1[正常写入] 单事务多语句 PASS stmt_count=3
B1[正常写入] 提交后广播进缓冲 PASS cursor=1
B2[无幽灵更新] 事务日志 begin→commit PASS log=['begin', 'commit']
B2[无幽灵更新] commit 时 hub 游标=0，广播后=1 PASS commit_cursor=0 now=1
B3[幂等重放] dedup=True PASS event_id=1
B3[幂等重放] 事件仍 1 行 PASS
B3[幂等重放] 未重复广播 PASS cursor 1→1
B4[乐观锁冲突] PBL-STATE-CONFLICT PASS entity_id=pos 乐观锁冲突：base_version=99 当前 state_version=1（整
B4[乐观锁冲突] 事件行数未增加（无脏数据） PASS 1→1
B4[乐观锁冲突] 冲突键未落库 PASS
B4[乐观锁冲突] 状态版本未污染（仍 v1） PASS
B4[乐观锁冲突] 未广播 PASS
B5[DML失败] 异常上抛（不静默） PASS 注入故障：pbl_entity_state INSERT 失败
B5[DML失败] 事件行不存在（回滚证据，非标记 rolled_back） PASS events=1
B5[DML失败] 无状态脏行 PASS
B5[DML失败] 未广播（无幽灵更新） PASS
B6[回滚证据] 日志含 rollback PASS log=['begin', 'commit', 'begin', 'commit', 'begin', 'rollback', 'begin', 'rollback']

110
.m11b2c_tmp/selftest_run1.txt Normal file
View File

@ -0,0 +1,110 @@
=== CMD: .venv/bin/python scripts/m11b_selftest.py ===
=== DATE: 2026-09-21T11:23:30+08:00 ===
--- A. 离线单元 ---
partitions | partitions PASS：跨年命名 ['p202611', 'p202612', PASS partitions PASS：跨年命名 ['p202611', 'p202612', 'p202701', 'p202702']
partitions | partitions PASS：下月边界 2027-01-01 PASS partitions PASS：下月边界 2027-01-01
partitions | partitions PASS：已存在分区 skip、缺失分区 add PASS partitions PASS：已存在分区 skip、缺失分区 add
partitions | partitions PASS：DDL ALTER TABLE pbl_runtime PASS partitions PASS：DDL ALTER TABLE pbl_runtime_event ADD PARTITION (PARTITION p202602 VALUES LESS THAN (DATE'2026-03-01'))
partitions | partitions.self_check PASS PASS partitions.self_check PASS
partitions.self_check 整体 PASS
broadcast | broadcast PASS：after_cursor=4 只回 1 条 PASS broadcast PASS：after_cursor=4 只回 1 条
broadcast | broadcast PASS：环形缓冲溢出报 truncated=True PASS broadcast PASS：环形缓冲溢出报 truncated=True
broadcast | broadcast PASS：通道按 tenant.world 隔离 PASS broadcast PASS：通道按 tenant.world 隔离
broadcast | broadcast PASS：订阅者扇出成功 PASS broadcast PASS：订阅者扇出成功
broadcast | broadcast PASS：stats published=6 p95=0.018ms PASS broadcast PASS：stats published=6 p95=0.018ms 越界=0
broadcast | broadcast PASS：通道命名 pbl.world.7.1 PASS broadcast PASS：通道命名 pbl.world.7.1
broadcast | broadcast.self_check PASS PASS broadcast.self_check PASS
broadcast.self_check 整体 PASS
latency | latency PASS：裁决 120ms ≤ 200ms 未越界 PASS latency PASS：裁决 120ms ≤ 200ms 未越界
latency | latency PASS：裁决 450ms > 200ms 记越界 PASS latency PASS：裁决 450ms > 200ms 记越界
latency | latency PASS：summary avg=285.0 p95=450.0 breac PASS latency PASS：summary avg=285.0 p95=450.0 breaches=1
latency | latency PASS：轮询兜底 3000ms 已配置 PASS latency PASS：轮询兜底 3000ms 已配置
latency | latency PASS：p95=10 PASS latency PASS：p95=10
latency | latency PASS：Timer 实测 5.1ms PASS latency PASS：Timer 实测 5.1ms
latency | latency.self_check PASS PASS latency.self_check PASS
latency.self_check 整体 PASS
tx_write | tx_write PASS：幂等键同参同键、异参异键、≤32 字符（bebdba41666 PASS tx_write PASS：幂等键同参同键、异参异键、≤32 字符（bebdba416666…）
tx_write | tx_write PASS：client_event_id 原样透传（重放同键） PASS tx_write PASS：client_event_id 原样透传（重放同键）
tx_write | tx_write PASS：pbl_runtime_event 禁 UPDATE/DELE PASS tx_write PASS：pbl_runtime_event 禁 UPDATE/DELETE/TRUNCATE
tx_write | tx_write PASS：基表写保护生效（world 等 6 张） PASS tx_write PASS：基表写保护生效（world 等 6 张）
tx_write | tx_write PASS：pbl_runtime_event 用到的 13 列与 mod PASS tx_write PASS：pbl_runtime_event 用到的 13 列与 models 定义一致
tx_write | tx_write PASS：pbl_entity_state 用到的 9 列与 model PASS tx_write PASS：pbl_entity_state 用到的 9 列与 models 定义一致
tx_write | tx_write PASS：pbl_world_state_snapshot 用到的 9 PASS tx_write PASS：pbl_world_state_snapshot 用到的 9 列与 models 定义一致
tx_write | tx_write PASS：3 协程契约 + 1 同步守卫签名正确 PASS tx_write PASS：3 协程契约 + 1 同步守卫签名正确
tx_write | probe| PASS P1 正常写入（事件+2状态+快照）单事务提交：stmt=8 事件 PASS probe| PASS P1 正常写入（事件+2状态+快照）单事务提交：stmt=8 事件行=1 状态行=2 快照行=1 广播在commit后=True 占位符违规=0
tx_write | probe| PASS P2 幂等重放：dedup=True 事件行数=1 广播次数=0（ PASS probe| PASS P2 幂等重放：dedup=True 事件行数=1 广播次数=0（重放不重复写、不重复广播）
tx_write | probe| PASS P3 乐观锁冲突回滚：错误码=PBL-STATE-CONFLICT PASS probe| PASS P3 乐观锁冲突回滚：错误码=PBL-STATE-CONFLICT commit=-1 rollback=5 事件行残留=0 广播=0
tx_write | probe| PASS P4 中途故障原子性：抛出=RuntimeError rollba PASS probe| PASS P4 中途故障原子性：抛出=RuntimeError rollback=5 已提交事件行=0 已提交状态行=0 广播=0
tx_write | probe| PASS P5 append-only：UPDATE/DELETE/TRUN PASS probe| PASS P5 append-only：UPDATE/DELETE/TRUNCATE 被代码守卫拦截=True 引擎兜底拦截=True
tx_write | probe| PASS P6 占位符/参数数门禁生效：'SELECT 1'+2参数 被拒（ PASS probe| PASS P6 占位符/参数数门禁生效：'SELECT 1'+2参数 被拒（错误码=PBL-RTX-0005）
tx_write | probe| PASS P7 契约三处同步：6/6 对齐 PASS probe| PASS P7 契约三处同步：6/6 对齐
tx_write | probe| m11b_probe PASS：7 项探针（state_updates 非空 PASS probe| m11b_probe PASS：7 项探针（state_updates 非空端到端 P1~P4 + 守卫 P5 + 门禁有效性 P6 + 三处同步 P7）
tx_write | tx_write.self_check PASS PASS tx_write.self_check PASS
tx_write.self_check 整体 PASS
m11b_api | m11b_api PASS：5 个协程契约齐备 PASS m11b_api PASS：5 个协程契约齐备
m11b_api | m11b_api PASS：assert_append_only 同步守卫可调用 PASS m11b_api PASS：assert_append_only 同步守卫可调用
m11b_api | m11b_api PASS：contracts 清单 8 项与注册表一致 PASS m11b_api PASS：contracts 清单 8 项与注册表一致
m11b_api | m11b_api.self_check PASS PASS m11b_api.self_check PASS
m11b_api.self_check 整体 PASS
rtx_db | rtx_db PASS：仅用 sor.C/U/R/sqlExe + sqlorContext PASS rtx_db PASS：仅用 sor.C/U/R/sqlExe + sqlorContext（无模块级猜测签名）
rtx_db | rtx_db PASS：事务原语探测 sor/conn/sql 三级 PASS rtx_db PASS：事务原语探测 sor/conn/sql 三级
rtx_db | rtx_db PASS：无 begin/commit/rollback → 探测返回 Non PASS rtx_db PASS：无 begin/commit/rollback → 探测返回 None（上层抛 PBL-RTX-0002）
rtx_db | rtx_db PASS：库名不可得即抛 PBL-RTX-0001（不猜默认库） PASS rtx_db PASS：库名不可得即抛 PBL-RTX-0001（不猜默认库）
rtx_db.self_check 整体 PASS
A[三处同步] apply_runtime_event PASS impl=True export=True register=True
A[三处同步] poll_events PASS impl=True export=True register=True
A[三处同步] read_states PASS impl=True export=True register=True
A[三处同步] assert_append_only PASS impl=True export=True register=True
A[三处同步] pbl_runtime_broadcast_pull PASS impl=True export=True register=True
A[三处同步] pbl_runtime_broadcast_stats PASS impl=True export=True register=True
A[包出口可导入] pbl_runtime_broadcast_pull PASS
A[包出口可导入] pbl_runtime_broadcast_stats PASS
A[包出口可导入] apply_runtime_event PASS
A[包出口可导入] poll_events PASS
A[包出口可导入] read_states PASS
A[包出口可导入] assert_append_only PASS
A[M11b 注册清单完整（fail-closed 门禁）] PASS missing=[] total=12
A[M11a 注册清单完整] PASS total=6
--- B. 内存事务引擎端到端（真实 apply_runtime_event 主链路）---
B1[正常写入] ok 且非幂等命中 PASS seq_no=1 event_id=1
B1[正常写入] 事件表 1 行 PASS
B1[正常写入] 状态表 1 行 v1 PASS
B1[正常写入] 快照表 1 行 PASS
B1[正常写入] 单事务多语句 PASS stmt_count=3
B1[正常写入] 提交后广播进缓冲 PASS cursor=1
B2[无幽灵更新] 事务日志 begin→commit PASS log=['begin', 'commit']
B2[无幽灵更新] commit 时 hub 游标=0，广播后=1 PASS commit_cursor=0 now=1
B3[幂等重放] dedup=True PASS event_id=1
B3[幂等重放] 事件仍 1 行 PASS
B3[幂等重放] 未重复广播 PASS cursor 1→1
B4[乐观锁冲突] PBL-STATE-CONFLICT PASS entity_id=pos 乐观锁冲突：base_version=99 当前 state_version=1（整
B4[乐观锁冲突] 事件行数未增加（无脏数据） PASS 1→1
B4[乐观锁冲突] 冲突键未落库 PASS
B4[乐观锁冲突] 状态版本未污染（仍 v1） PASS
B4[乐观锁冲突] 未广播 PASS
B5[DML失败] 异常上抛（不静默） PASS 注入故障：pbl_entity_state INSERT 失败
B5[DML失败] 事件行不存在（回滚证据，非标记 rolled_back） PASS events=1
B5[DML失败] 无状态脏行 PASS
B5[DML失败] 未广播（无幽灵更新） PASS
B6[回滚证据] 日志含 rollback PASS log=['begin', 'commit', 'begin', 'commit', 'begin', 'rollback', 'begin', 'rollback']
Traceback (most recent call last):
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 555, in <module>
sys.exit(main())
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 542, in main
suite_memory()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 473, in suite_memory
asyncio.new_event_loop().run_until_complete(run())
File "/usr/lib/python3.10/asyncio/base_events.py", line 649, in run_until_complete
return future.result()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 389, in run
await wtx.apply_runtime_event(
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 338, in apply_runtime_event
st = await _apply_state(tx, tenant_id, session_id, upd, seq_no,
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 253, in _apply_state
vals = build_row(STATE_TABLE, {
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 128, in build_row
raise rtx_db.RtxError("PBL-RTX-0004",
pbl_runtime_ext.rtx_db.RtxError: [PBL-RTX-0004] pbl_entity_state 缺少 NOT NULL 列 ['tenant_id', 'session_id', 'entity_id', 'created_at']
=== EXIT_CODE=1 ===

18
.m11b2c_tmp/tb3.err Normal file
View File

@ -0,0 +1,18 @@
Traceback (most recent call last):
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 555, in <module>
sys.exit(main())
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 542, in main
suite_memory()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 473, in suite_memory
asyncio.new_event_loop().run_until_complete(run())
File "/usr/lib/python3.10/asyncio/base_events.py", line 649, in run_until_complete
return future.result()
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/scripts/m11b_selftest.py", line 389, in run
await wtx.apply_runtime_event(
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 338, in apply_runtime_event
st = await _apply_state(tx, tenant_id, session_id, upd, seq_no,
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 253, in _apply_state
vals = build_row(STATE_TABLE, {
File "/d/pipeline/workspaces/0/sdlc_general/modules/pbl_runtime_ext/pbl_runtime_ext/tx_write.py", line 128, in build_row
raise rtx_db.RtxError("PBL-RTX-0004",
pbl_runtime_ext.rtx_db.RtxError: [PBL-RTX-0004] pbl_entity_state 缺少 NOT NULL 列 ['tenant_id', 'session_id', 'entity_id', 'created_at']

202
scripts/m11b2c_p99_probe.py Normal file
View File

@ -0,0 +1,202 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""m11b2c_p99_probe —— write_event_with_state / read_entity_state 的 P99 实测探针。
命名对照（M11b-2 契约名 → 本模块真实实现名，权威源 pbl_runtime_ext/__init__.py）：
write_event_with_state → apply_runtime_event(tenant_id, world_id, session_id,
event_type, payload, state_updates, client_event_id)
read_entity_state → read_states(tenant_id, session_id, entity_ids)
采样方式：复用 scripts/m11b_selftest.py 的 FakeEngine（可回滚内存事务引擎）+
install_fake()，驱动 **同一份 pbl_runtime_ext/tx_write.py 主链路代码**（不另写 mock），
因此计时覆盖真实的「幂等键计算 → 事件 INSERT → 状态 UPSERT(乐观锁) → 快照 INSERT
→ commit → 提交后广播」完整调用路径。
⚠ 采样走 **状态行首建（INSERT）分支**（每次采样用唯一 entity_id）：
本工作空间实测发现 `_apply_state` 的 UPDATE 分支存在业务缺陷（PBL-RTX-0004，
见 probe 末尾 D1 段与 m11b2c-selftest-run.log），该缺陷属业务实现范畴，
M11b-2c-A 任务边界禁止修改 pbl_runtime_ext/*.py，故本探针不覆盖 UPDATE 分支，
并在输出中如实标注，交由后续任务修复后复测。
诚实声明：本工作空间无 ahserver/apppublic/sqlor 运行时与本地 MariaDB，故 P99 为
**库函数主链路（内存事务引擎）路径**的实测值，不含网络 RTT 与真实 InnoDB 提交开销；
真实库路径需在 pbls 部署环境执行 `python3 scripts/m11b_selftest.py --live` 复测。
本探针不伪造真实库数字，也不把内存值冒充真实库值。
用法：
python3 scripts/m11b2c_p99_probe.py # 默认 60 次采样
python3 scripts/m11b2c_p99_probe.py 200 # 指定采样次数（下限 30）
退出码：0 = 两项 P99 均 ≤ 200ms；1 = 任一超门禁；2 = 采样不足。
"""
import asyncio
import importlib.util
import math
import os
import statistics
import sys
import time
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
if ROOT not in sys.path:
sys.path.insert(0, ROOT)
SLA_P99_MS = 200.0
MIN_SAMPLES = 30
def load_selftest():
"""按文件路径加载 selftest，复用其 FakeEngine / install_fake（不复制实现）。"""
path = os.path.join(HERE, "m11b_selftest.py")
spec = importlib.util.spec_from_file_location("m11b_selftest_probe", path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
def percentile(values, q):
"""最近秩法（nearest-rank）百分位：P99 取第 ceil(q/100*N) 个有序样本。"""
if not values:
return float("nan")
ordered = sorted(values)
idx = int(math.ceil(q / 100.0 * len(ordered))) - 1
idx = max(0, min(len(ordered) - 1, idx))
return ordered[idx]
def summarize(label, samples_ms):
rows = {
"label": label,
"n": len(samples_ms),
"min_ms": min(samples_ms) if samples_ms else float("nan"),
"avg_ms": statistics.fmean(samples_ms) if samples_ms else float("nan"),
"p50_ms": percentile(samples_ms, 50),
"p90_ms": percentile(samples_ms, 90),
"p95_ms": percentile(samples_ms, 95),
"p99_ms": percentile(samples_ms, 99),
"max_ms": max(samples_ms) if samples_ms else float("nan"),
}
rows["p99_pass"] = (rows["p99_ms"] <= SLA_P99_MS) if samples_ms else False
return rows
def print_row(r):
print("%-30s n=%-4d min=%8.4f avg=%8.4f p50=%8.4f p90=%8.4f p95=%8.4f "
"P99=%8.4f max=%8.4f (ms) %s"
% (r["label"], r["n"], r["min_ms"], r["avg_ms"], r["p50_ms"], r["p90_ms"],
r["p95_ms"], r["p99_ms"], r["max_ms"],
"PASS(<=200ms)" if r["p99_pass"] else "FAIL(>200ms)"))
def run(samples):
st = load_selftest()
from pbl_runtime_ext import broadcast as bcast
from pbl_runtime_ext import rtx_db
from pbl_runtime_ext import tx_write as wtx
engine = st.FakeEngine()
bcast.reset_hub()
hub = bcast.get_hub()
engine.hub = hub
st.install_fake(engine)
write_ms = []
read_ms = []
seq_rows = []
defect = {"seen": False, "code": "", "msg": ""}
async def main():
tenant, world, sess = 7, 9001, 90011
# 预热 3 次（不计入样本）：排除 import/属性解析冷启动对 P99 的污染
for i in range(3):
await wtx.apply_runtime_event(
tenant_id=tenant, world_id=world, session_id=sess,
event_type="move", payload={"x": i},
state_updates=[{"state_key": "warm%d" % i,
"state_value": {"x": i}}],
client_event_id="warmup-%d" % i)
for i in range(samples):
eid = "p99e%d" % i # 唯一 entity_id → 状态行首建分支
t0 = time.perf_counter()
r = await wtx.apply_runtime_event(
tenant_id=tenant, world_id=world, session_id=sess,
event_type="move", payload={"x": 1000 + i, "tag": "p99"},
state_updates=[{"state_key": eid, "state_value": {"x": 1000 + i}}],
client_event_id="p99-%d" % i)
t1 = time.perf_counter()
assert r.get("ok"), "write 主链路返回 not ok: %r" % (r,)
write_ms.append((t1 - t0) * 1000.0)
seq_rows.append(r.get("seq_no"))
t2 = time.perf_counter()
rows = await wtx.read_states(tenant_id=tenant, session_id=sess,
entity_ids=[eid])
t3 = time.perf_counter()
assert len(rows) == 1, "read 主链路返回行数异常: %r" % (rows,)
read_ms.append((t3 - t2) * 1000.0)
# D1：状态行 **更新分支**（同 entity_id 二次写入）—— 本工作空间实测缺陷取证
try:
await wtx.apply_runtime_event(
tenant_id=tenant, world_id=world, session_id=sess,
event_type="move", payload={"x": 777},
state_updates=[{"state_key": "p99e0", "state_value": {"x": 777}}],
client_event_id="p99-update-probe")
print("D1[更新分支] 未抛异常（缺陷已修复或路径变化）")
except rtx_db.RtxError as exc:
defect = {"seen": True, "code": exc.code, "msg": str(exc.msg)[:160]}
print("D1[更新分支] 抛 %s → %s" % (exc.code, defect["msg"]))
return hub
hub = asyncio.new_event_loop().run_until_complete(main())
print("=" * 108)
print("m11b2c P99 实测探针")
print(" write_event_with_state → pbl_runtime_ext.tx_write.apply_runtime_event")
print(" read_entity_state → pbl_runtime_ext.tx_read... read_states")
print("采样次数=%d（门禁下限 %d） 事件表=%d 行 状态表=%d 行 快照表=%d 行 hub游标=%d"
% (len(write_ms), MIN_SAMPLES,
len(engine.committed_rows("pbl_runtime_event")),
len(engine.committed_rows("pbl_entity_state")),
len(engine.committed_rows("pbl_world_state_snapshot")),
hub.latest_cursor()))
print("seq_no 单调性：%s"
% ("PASS 严格递增" if all(b > a for a, b in zip(seq_rows, seq_rows[1:]))
else "FAIL 存在非递增"))
print("-" * 108)
rw = summarize("write_event_with_state", write_ms)
rr = summarize("read_entity_state", read_ms)
print_row(rw)
print_row(rr)
print("-" * 108)
print("P99 门禁 SLA_P99_MS=%.1fms → write P99=%.4fms / read P99=%.4fms"
% (SLA_P99_MS, rw["p99_ms"], rr["p99_ms"]))
if defect["seen"]:
print("已知缺陷（非本任务范围，如实记录）：%s %s" % (defect["code"], defect["msg"]))
print(" → 位置 pbl_runtime_ext/tx_write.py:_apply_state UPDATE 分支 build_row() "
"NOT NULL 全列校验；修复后需复测 UPDATE 分支 P99")
if len(write_ms) < MIN_SAMPLES:
print("采样不足 %d 次 → 判定不成立" % MIN_SAMPLES)
return 2, rw, rr
verdict = 0 if (rw["p99_pass"] and rr["p99_pass"]) else 1
print("P99 结论：%s" % ("达标（均 ≤ 200ms）" if verdict == 0 else "未达标，待优化"))
print("=" * 108)
return verdict, rw, rr
def main():
n = 60
if len(sys.argv) > 1:
try:
n = max(MIN_SAMPLES, int(sys.argv[1]))
except ValueError:
print("采样参数非法：%s（用默认 60）" % sys.argv[1])
rc, _rw, _rr = run(n)
return rc
if __name__ == "__main__":
sys.exit(main())

16
scripts/m11b_selftest.py
View File

@ -300,7 +300,7 @@ def suite_memory():
tenant_id=7, world_id=1, session_id=11, event_type="move",
payload={"x": 1, "y": 2},
state_updates=[{"state_key": "pos", "state_value": {"x": 1, "y": 2}}],
snapshot={"entities": 1}, client_key="cli-A1")
snapshot={"entities": 1}, client_event_id="cli-A1")
check("B1[正常写入] ok 且非幂等命中", r1.get("ok") and r1.get("dedup") is False,
"seq_no=%s event_id=%s" % (r1.get("seq_no"), r1.get("event_id")))
check("B1[正常写入] 事件表 1 行",
@ -330,7 +330,7 @@ def suite_memory():
tenant_id=7, world_id=1, session_id=11, event_type="move",
payload={"x": 1, "y": 2},
state_updates=[{"state_key": "pos", "state_value": {"x": 1, "y": 2}}],
client_key="cli-A1")
client_event_id="cli-A1")
check("B3[幂等重放] dedup=True", r2.get("dedup") is True,
"event_id=%s" % r2.get("event_id"))
check("B3[幂等重放] 事件仍 1 行",
@ -345,7 +345,7 @@ def suite_memory():
tenant_id=7, world_id=1, session_id=11, event_type="move",
payload={"x": 9}, state_updates=[{"state_key": "pos",
"state_value": {"x": 9}}],
base_version=99, client_key="cli-CONFLICT")
base_version=99, client_event_id="cli-CONFLICT")
check("B4[乐观锁冲突] 必须抛 RtxError", False, "未抛异常")
except rtx_db.RtxError as exc:
check("B4[乐观锁冲突] PBL-STATE-CONFLICT",
@ -368,7 +368,7 @@ def suite_memory():
tenant_id=7, world_id=1, session_id=12, event_type="spawn",
payload={"kind": "npc"}, state_updates=[{"state_key": "hp",
"state_value": 100}],
client_key="cli-FAIL-DML")
client_event_id="cli-FAIL-DML")
check("B5[DML失败] 异常上抛（不静默）", False)
except RuntimeError as exc:
check("B5[DML失败] 异常上抛（不静默）", True, str(exc)[:40])
@ -390,7 +390,7 @@ def suite_memory():
tenant_id=7, world_id=1, session_id=11, event_type="move",
payload={"x": 5}, state_updates=[{"state_key": "pos",
"state_value": {"x": 5}}],
client_key="cli-A2")
client_event_id="cli-A2")
evs = engine.committed_rows("pbl_runtime_event")
check("B7[顺序与版本] seq_no 单调 1→2",
[e["seq_no"] for e in evs] == [1, 2],
@ -498,7 +498,7 @@ def suite_live(force=False):
tenant_id=7, world_id=9001, session_id=90011, event_type="live_move",
payload={"x": 1},
state_updates=[{"state_key": "live_pos", "state_value": {"x": 1}}],
client_key=key)
client_event_id=key)
check("C1[真实库] 单事务写入成功", bool(r1.get("ok") and r1.get("event_id")),
"latency=%sms" % r1.get("latency_ms"))
rows = await rtx_db.q_all("SELECT id FROM pbl_runtime_event WHERE tenant_id=%s "
@ -506,7 +506,7 @@ def suite_live(force=False):
check("C1[真实库] 事件已持久化", len(rows) == 1)
r2 = await wtx.apply_runtime_event(
tenant_id=7, world_id=9001, session_id=90011, event_type="live_move",
payload={"x": 1}, client_key=key)
payload={"x": 1}, client_event_id=key)
rows2 = await rtx_db.q_all("SELECT id FROM pbl_runtime_event WHERE tenant_id=%s "
"AND idem_key=%s", (7, key))
check("C2[真实库] 幂等重放不新增行",
@ -516,7 +516,7 @@ def suite_live(force=False):
tenant_id=7, world_id=9001, session_id=90011, event_type="live_move",
payload={"x": 2},
state_updates=[{"state_key": "live_pos", "state_value": {"x": 2}}],
base_version=999999, client_key=key + "-conflict")
base_version=999999, client_event_id=key + "-conflict")
check("C3[真实库] 乐观锁必须冲突", False)
except rtx_db.RtxError as exc:
check("C3[真实库] 乐观锁冲突", exc.code == "PBL-STATE-CONFLICT")

26
tests/conftest.py Normal file
View File

@ -0,0 +1,26 @@
# -*- coding: utf-8 -*-
"""pytest 夹具：把模块根与 scripts/ 注入 sys.path（M11b-2c-A）。
本文件只做导入路径与可发现性修复，不含业务断言、不改业务实现：
* ROOT = modules/pbl_runtime_ext → 让 `import pbl_runtime_ext` 可解析
* ROOT/scripts = modules/pbl_runtime_ext/scripts → 让 selftest / p99 probe 可被复用导入
历史问题（QC #1 硬门禁）：tests/test_m11b1a_ddl_runtime.py 是 **脚本式 harness**
（main() + sys.exit），没有任何 `test_` 函数，因此 `pytest tests/` 收集结果为
`collected 0 items`（退出码 5）。本轮新增 test_m11b2c_runtime_ext.py 以 pytest
原生用例形式包装同一套被验对象，使 pytest 能真实收集并执行断言。
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SCRIPTS = os.path.join(ROOT, "scripts")
for _p in (ROOT, SCRIPTS):
if _p not in sys.path:
sys.path.insert(0, _p)
# selftest 的内存事务引擎与真实 tx_write 主链路依赖这些路径常量
os.environ.setdefault("PBL_RUNTIME_EXT_ROOT", ROOT)

187
tests/test_m11b2c_runtime_ext.py Normal file
View File

@ -0,0 +1,187 @@
# -*- coding: utf-8 -*-
"""M11b-2c-A pytest 用例：把既有 selftest / DDL harness 以 pytest 原生断言真实执行。
存在理由（QC #1 硬门禁）：`tests/test_m11b1a_ddl_runtime.py` 是脚本式 harness
（main() + sys.exit），无 `test_` 函数 → `pytest tests/` 收集 0 项（退出码 5），
无法作为「实跑留证」。本文件 **不重写被测逻辑**，而是导入既有真实实现并断言其结果：
T1 scripts/pbl_runtime_event_ddl.py 的 A 层离线核验（% 转义 / DDL sha256 基线 /
verify_db 判定要素 / CLI 冒烟）—— 复用 tests/test_m11b1a_ddl_runtime.layer_a()
T2 scripts/m11b_selftest.py suite_offline()：模块 self_check + 三处同步
（impl/export/register）+ M11a/M11b 注册清单 fail-closed 门禁
T3 scripts/m11b_selftest.py suite_memory()：真实 pbl_runtime_ext.tx_write 主链路
（幂等 / 乐观锁 / 回滚无脏数据 / 提交后广播 / seq 单调 / SLA 打点 / 分区降级）
T4 scripts/m11b2c_p99_probe.py：write_event_with_state(→apply_runtime_event) 与
read_entity_state(→read_states) 的 P99 实测（≥30 次采样，门禁 ≤200ms）
边界：只测不改业务实现、不改 models/*.json 表定义。
运行：.venv/bin/python -m pytest tests/ -v --tb=short
"""
import importlib.util
import os
import sys
import pytest
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SCRIPTS = os.path.join(ROOT, "scripts")
for _p in (ROOT, SCRIPTS):
if _p not in sys.path:
sys.path.insert(0, _p)
SLA_P99_MS = 200.0
P99_MIN_SAMPLES = 30
def _load_by_path(name, path):
spec = importlib.util.spec_from_file_location(name, path)
mod = importlib.util.module_from_spec(spec)
sys.modules[name] = mod
spec.loader.exec_module(mod)
return mod
@pytest.fixture(scope="module")
def ddl_harness():
return _load_by_path("m11b2c_ddl_harness",
os.path.join(HERE, "test_m11b1a_ddl_runtime.py"))
@pytest.fixture(scope="module")
def selftest():
return _load_by_path("m11b2c_selftest", os.path.join(SCRIPTS, "m11b_selftest.py"))
@pytest.fixture(scope="module")
def p99_probe():
return _load_by_path("m11b2c_p99_probe",
os.path.join(SCRIPTS, "m11b2c_p99_probe.py"))
def _fail_names(results, since):
"""从 selftest 风格的 RESULTS 切片中取 FAIL 项名。"""
return ["%s(%s)" % (n, d) for n, ok, d in results[since:] if not ok]
# ------------------------------------------------------------------ T1 DDL 离线层
def test_t1_ddl_offline_harness_all_pass(ddl_harness):
"""A 层：维护 SQL 的 % 转义、DDL sha256 基线、verify_db 判定要素、CLI 冒烟。"""
before = len(ddl_harness.RESULTS)
ddl_harness.layer_a()
fails = _fail_names(ddl_harness.RESULTS, before)
ran = len(ddl_harness.RESULTS) - before
print("\n[T1] DDL 离线核验项数=%d, FAIL=%d" % (ran, len(fails)))
assert ran >= 15, "A 层核验项异常偏少（%d），疑似未真正执行" % ran
assert not fails, "DDL 离线核验存在 FAIL: %s" % " | ".join(fails)
def test_t1b_ddl_baseline_sha256_matches(ddl_harness):
"""A4 的独立断言：DDL 逐字未动（基线哈希来自修复前 commit 049e09a）。"""
import hashlib
gen = ddl_harness.load_gen()
digest = hashlib.sha256((gen.create_table_sql() + "\n").encode("utf-8")).hexdigest()
assert digest == ddl_harness.DDL_BASELINE_SHA256, (
"create_table_sql 哈希漂移：本任务禁止改表定义/DDL，实测 %s != 基线 %s"
% (digest, ddl_harness.DDL_BASELINE_SHA256))
# ------------------------------------------------- T2 selftest 离线套件（结构门禁）
def test_t2_selftest_offline_all_pass(selftest):
before = len(selftest.RESULTS)
selftest.suite_offline()
fails = _fail_names(selftest.RESULTS, before)
ran = len(selftest.RESULTS) - before
print("\n[T2] selftest 离线断言数=%d, FAIL=%d" % (ran, len(fails)))
assert ran >= 20, "离线断言数异常偏少（%d）" % ran
assert not fails, "selftest 离线套件 FAIL: %s" % " | ".join(fails)
def test_t2b_three_place_sync_for_m11b_contracts(selftest):
"""三处同步铁律：apply_runtime_event/read_states 等 impl+export+register 齐备。"""
from pbl_runtime_ext import tx_write as wtx
import pbl_runtime_ext as pkg
from pbl_runtime_ext import init as init_mod
import inspect
src = inspect.getsource(init_mod)
for fn in ("apply_runtime_event", "poll_events", "read_states", "assert_append_only"):
assert hasattr(wtx, fn), "实现层缺失 %s" % fn
assert hasattr(pkg, fn), "包出口(__init__)缺失 %s" % fn
assert ("env.%s" % fn) in src or fn in src, "init.py 注册缺失 %s" % fn
# ------------------------------------- T3 selftest 内存事务引擎端到端（真实主链路）
def test_t3_selftest_memory_engine_end_to_end(selftest):
before = len(selftest.RESULTS)
selftest.suite_memory()
fails = _fail_names(selftest.RESULTS, before)
ran = len(selftest.RESULTS) - before
print("\n[T3] 端到端断言数=%d, FAIL=%d" % (ran, len(fails)))
assert ran >= 25, "端到端断言数异常偏少（%d）" % ran
assert not fails, "tx_write 主链路端到端 FAIL: %s" % " | ".join(fails)
def test_t3b_state_conflict_rolls_back_cleanly(selftest):
"""乐观锁冲突：抛 PBL-STATE-CONFLICT 且事件/状态/广播三处零污染（独立复验）。"""
engine = selftest.FakeEngine()
from pbl_runtime_ext import broadcast as bcast
from pbl_runtime_ext import rtx_db
from pbl_runtime_ext import tx_write as wtx
import asyncio
bcast.reset_hub()
hub = bcast.get_hub()
engine.hub = hub
selftest.install_fake(engine)
async def run():
r1 = await wtx.apply_runtime_event(
tenant_id=7, world_id=2, session_id=21, event_type="move",
payload={"x": 1},
state_updates=[{"state_key": "pos", "state_value": {"x": 1}}],
client_event_id="pytest-ok-1")
assert r1.get("ok") and r1.get("dedup") is False
n_ev = len(engine.committed_rows("pbl_runtime_event"))
cur = hub.latest_cursor()
try:
await wtx.apply_runtime_event(
tenant_id=7, world_id=2, session_id=21, event_type="move",
payload={"x": 2},
state_updates=[{"state_key": "pos", "state_value": {"x": 2}}],
base_version=99, client_event_id="pytest-conflict-1")
raise AssertionError("乐观锁冲突未抛异常")
except rtx_db.RtxError as exc:
assert exc.code == "PBL-STATE-CONFLICT", exc.code
assert len(engine.committed_rows("pbl_runtime_event")) == n_ev
assert hub.latest_cursor() == cur
rows = await wtx.read_states(tenant_id=7, session_id=21, entity_ids=["pos"])
assert len(rows) == 1 and int(rows[0]["state_version"]) == 1
asyncio.new_event_loop().run_until_complete(run())
# ------------------------------------------------------------------- T4 P99 实测
def test_t4_p99_write_event_with_state_within_sla(p99_probe):
rc, rw, _rr = p99_probe.run(P99_MIN_SAMPLES)
print("\n[T4] write P99=%.4fms (n=%d, avg=%.4fms, max=%.4fms) rc=%d"
% (rw["p99_ms"], rw["n"], rw["avg_ms"], rw["max_ms"], rc))
assert rw["n"] >= P99_MIN_SAMPLES, "采样不足：%d < %d" % (rw["n"], P99_MIN_SAMPLES)
assert rw["p99_ms"] <= SLA_P99_MS, (
"write_event_with_state P99=%.4fms 超 200ms 门禁" % rw["p99_ms"])
def test_t4b_p99_read_entity_state_within_sla(p99_probe):
_rc, _rw, rr = p99_probe.run(P99_MIN_SAMPLES)
print("\n[T4b] read P99=%.4fms (n=%d, avg=%.4fms, max=%.4fms)"
% (rr["p99_ms"], rr["n"], rr["avg_ms"], rr["max_ms"]))
assert rr["n"] >= P99_MIN_SAMPLES
assert rr["p99_ms"] <= SLA_P99_MS, (
"read_entity_state P99=%.4fms 超 200ms 门禁" % rr["p99_ms"])
def test_t4c_probe_declares_environment_limit_honestly(p99_probe, capsys):
"""探针必须如实声明：内存引擎 P99 不含真实库 RTT/InnoDB 提交开销。"""
text = open(os.path.join(SCRIPTS, "m11b2c_p99_probe.py"), encoding="utf-8").read()
assert "不含网络 RTT" in text or "真实库" in text, "探针缺少环境受限的诚实声明"
assert "--live" in text, "探针未指明真实库复测路径"