test(pack): 每个包的 List 必须在面 A + 面 B 真应答(批次 12.6)

12.5 让「漏接」变红,但「接错了」仍全绿:路径注册了(405 探针)不等于 handler 跑得通。

- tests/pack_smoke_it.rs:登录 → 遍历 ALL_SPECS/ALL_ROUTES + 包注册表 → 真打 List

  面 A 断言 data 是裸数组;面 B 断言 data.list 是数组且 pagination.total 非空

  一个条目都不写死 ⇒ 加包自动覆盖;失败时一次列全部坏条目

- verify.sh --lib 新增该步(full/smoke 已由 --workspace 覆盖,不重复跑),+2.4s

- 顺手修两处文档失真:测试二进制 45 → 实测 37;--lib 描述「不起库」→「起库」
This commit is contained in:
admin committed 2026-11-01 23:13:42 +08:00
1 parent aa2447eec2
commit 324e82be0d
2 files changed
+266 -3

No files matched your search

+256
View File
@@ -0,0 +1,256 @@
//! pack_smoke —— **每个业务包的 List 必须真的应答**(面 A + 面 B)。
//!
//! 🔴 **与 `routes.rs::route_table_is_pinned` 的分工**(两者互补,别合并):
//!
//! | | 那条 | 这条 |
//! |---|---|---|
//! | 手法 | 静态探针(错方法 ⇒ 405) | 运行时冒烟(登录 ⇒ 查库 ⇒ 出 JSON) |
//! | 证明 | 「**路径注册了**」 | 「**handler 跑得通**」 |
//!
//! 两者之间那段正是**静默失败**的藏身处 —— 以下三种都**不会**红:
//!
//! 1. spec 加了列、DDL 没加 ⇒ 投影 SQL 报错 ⇒ 面 A / 面 B 都返 `code:400`
//! (闸门全绿,浏览器里只是「页面空着」);
//! 2. `module_key` 指向不存在的菜单 ⇒ 守卫返 403(同上);
//! 3. 包路由没 merge 进总路由 ⇒ 面 B 404(`pack_router_or_empty()` 的
//! `Err(_) => Router::new()` 是**有意**不 panic 的,见 `bootstrap.rs`)。
//!
//! 🔴 **一个条目都不写死**:全部从 `modules::ALL_SPECS` / `ALL_ROUTES` 与包注册表
//! **遍历**出来 ⇒ 加一个包**自动**被这条冒烟覆盖,不用改本文件。
//! 写死清单的冒烟 = 加了包还全绿 = 假闸门(批次 12.5 已踩过:
//! `asset_pack_loads` 那种「写死条数」的断言,加包时第一件事就是去改测试)。
//!
//! 🔴 **为什么只冒烟 List、不冒烟 Save / Delete**:
//! Save 需要**合法 body**,而 `ColumnSpec` **有意不带类型信息**
//! (只有 `numeric: bool` + `default`)⇒ 造不出对所有包都合法的 body
//! (`VARCHAR` 与 `TIMESTAMP` 在 spec 里长得一模一样)。
//! 退一步用 `{}` 又要求「业务列全部可空」—— 那是**业务决策**,
//! 平台不该替包作这个规定(`new-pack-gen.py` 的 `--columns` 允许写 `NOT NULL`)。
//! ⇒ 写 / 删留给各包自己的集成测试(`crud_it.rs` / `batch*_it.rs`);
//! 本条只钉**读路径**,而读路径恰好是「页面空着」这个症状的**全部来源**。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库;
//! 本文件只有一个测试函数 ⇒ 不需要互斥锁(测试内顺序执行)。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::Value;
use ssw_platform::bootstrap::{ensure_base, packs};
use ssw_platform::modules::{ALL_ROUTES, ALL_SPECS};
use ssw_platform::platform::config::Config;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::route::HttpMethod;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::SessionStore;
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::OnceCell;
static DB: OnceCell<Db> = OnceCell::const_new();
/// **与生产同一条装配链**的库(平台表 + 包表 + 平台种子 + 业务菜单 + admin)。
///
/// 🔴 三个调用一个都不能省:
/// - `ensure_schema_all` ⇒ 包自带的 DDL(**没有它 ⇒ 表不存在 ⇒ 面 A 必 400**);
/// - `ensure_base` ⇒ 平台表种子 + **业务菜单**(`ALL_MENUS`,没有它 ⇒ 守卫 403);
/// - `first_seed` ⇒ admin 账号(没有它 ⇒ 登录失败,整条冒烟跑不起来)。
/// ⇒ 这份清单本身就是「一个包在运行期需要内核做什么」的答案。
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-pack-smoke"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
/// 发一次 GET,返回 `(状态码, 解析后的 JSON)`。
///
/// `official` ⇒ 带官方判别头(`Vue-Version` / `App-Code`)——
/// 面 B 的中间件靠它分流(`routes.rs` 的 `get_face_b` 同口径)。
async fn get(port: u16, path: &str, token: &str, official: bool) -> (u16, Value) {
let extra = if official {
"Vue-Version: 3\r\nApp-Code: mainSystem\r\n"
} else {
""
};
let req = format!(
"GET {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
{extra}Authorization: {token}\r\n\
Connection: close\r\n\r\n"
);
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let status = head
.lines()
.next()
.and_then(|l| l.split_whitespace().nth(1))
.and_then(|s| s.parse::<u16>().ok())
.expect("响应首行必须是 HTTP/1.1 <code> ...");
let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
(status, json)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON");
json["data"]["token"]
.as_str()
.expect("登录必须返回 token(否则整条冒烟无法进行)")
.to_string()
}
/// 🔴 **每个包的 List 在两个面上都必须真的应答。**
///
/// 失败时**一次性列出全部坏掉的条目**(不是第一条就中断)——
/// 加包场景下通常一坏就是一片,逐条重跑才能看全 = 浪费。
#[tokio::test]
async fn every_pack_list_answers_on_both_faces() {
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 收集全部问题,最后一起报。
let mut bad: Vec<String> = Vec::new();
let mut checked = 0usize;
// ------------------------------------------------ 面 A(MVP 前端走这条)
assert_eq!(
ALL_ROUTES.len(),
ALL_SPECS.len() * 3,
"ALL_ROUTES 与 ALL_SPECS 必须按「每模块 3 条」配对(两段都是生成段,别手改)"
);
for (i, spec) in ALL_SPECS.iter().enumerate() {
let path = ALL_ROUTES[i * 3];
let (status, body) = get(port, path, &token, false).await;
checked += 1;
if status != 200 {
bad.push(format!(
"面 A {}({}/{})状态 {} ≠ 200",
path, spec.app_code, spec.entity, status
));
} else if body["code"] != 200 {
bad.push(format!(
"面 A {}({}/{})信封 code={} msg={}",
path, spec.app_code, spec.entity, body["code"], body["msg"]
));
} else if !body["data"].is_array() {
bad.push(format!(
"面 A {}({}/{})data 必须是裸数组,实际 {}",
path, spec.app_code, spec.entity, body["data"]
));
}
}
// ------------------------------------------------ 面 B(官方前端 / 集成期走这条)
let reg = packs().expect("全部业务包必须装载成功");
let lists: Vec<&'static str> = reg
.routes
.iter()
.filter(|r| r.method == HttpMethod::Get && !r.path.contains('{'))
.map(|r| r.path)
.collect();
assert_eq!(
lists.len(),
reg.entities.len(),
"每个实体恰好 1 条面 B 的 List 路由(漏 ⇒ 官方前端列表静默空着);实际 {:?}",
lists
);
for path in lists {
let (status, body) = get(port, path, &token, true).await;
checked += 1;
if status != 200 {
bad.push(format!("面 B {} 状态 {} ≠ 200", path, status));
} else if body["code"] != 200 {
bad.push(format!(
"面 B {} 信封 code={} msg={}",
path, body["code"], body["msg"]
));
} else if !body["data"]["list"].is_array() {
bad.push(format!(
"面 B {} 的 data 必须是 PageListVO(data.list 为数组),实际 {}",
path, body["data"]
));
} else if body["data"]["pagination"]["total"].is_null() {
bad.push(format!(
"面 B {} 缺 pagination.total(官方前端读它算总数),实际 {}",
path, body["data"]["pagination"]
));
}
}
// 空集合是 falsy 的经典陷阱 ⇒ 显式断言「真的检查过东西」。
assert!(
checked >= 2,
"至少要检查出面 A + 面 B 各一条;实际只检查了 {checked} 条 ⇒ 遍历逻辑坏了"
);
assert!(
bad.is_empty(),
"以下包/路由**静默坏了**(静态闸门全绿,但前端只会看到空页面):\n - {}",
bad.join("\n - ")
);
}