Files
ssw-platform/crates/tests/tests/batch2_it.rs
T
admin acf076df5a refactor: 内核瘦身 —— 示例搬成业务包 + 装配/测试各归其位
- 内核只有 lib:启动装配 → crates/sspf-admin(bin sspf-admin);37 个集成测试 → crates/tests(package sspf-tests)。
- demo/shop/books 的 spec/菜单/DDL/面 B 路由搬进 packs/{demo,shop,books};内核 modules/*.rs 只剩「面 A 适配器 + pub use」⇒ 内核零业务知识,示例可整目录搬走。面 A 与前端零改动。
- 示例表 DDL 按平台规则补 f_tenant_id + 复合主键(spec 不加 ⇒ JSON 键与响应逐字不变)。
- 修 is_builtin_table 只认 schema.sql 的漏洞:包表(含 asset_data_resource)此前可被建模页删除/改;现为「平台 DDL ∪ 包表」。
- sspf-compat-online_dev → onlinedev(包名/模块/文件/路由别名同步);6 个 5 行转发壳合并为 forward.rs。
- 新增 AR16 闸门 + lib.rs「30 秒地图」+ src/backend/README.md;pack-sync 补两处判据(module_key=None 的 urlAddress、apiFile 查存在性)。
- 回归:704 tests / 6 道静态闸门全绿;health 181 表;四个包面 A/面 B 运行时全部 200。
2026-11-04 14:46:12 +08:00

517 lines
17 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 批次 2(Standing / PermissionGroup / Action)集成测试。
//!
//! 🔴 **本文件专门钉三个曾经真出过的 bug**(都是「接口返 200 / 500 但功能不对」这一类):
//! ① `GET /PermissionGroup/PermissionMember/{id}` 用 `f_id = ANY($1::text[])` ⇒
//! pglite-rs 0.2.7 把 `$1::text[]` 当成 PG 数组类型 `_text` ⇒ 协议错 ⇒ 500 / data=null。
//! 修法:改成 `f_id = ANY(string_to_array($1::text, ','))`(**函数在 SQL 里做** ⇒ 参数仍是 text)。
//! ② `DELETE /PermissionGroup/{id}` 软删 `base_authorize` 的 SQL 带了 `$1`(删除人)
//! 但 WHERE/赋值里没真正用到 ⇒ PG 报 `42P18: could not determine data type of parameter $1`。
//! 修法:把 `f_delete_user_id = $1::text` 写进 SET。
//! ③ `DELETE /Standing/{id}` 软删关联的**占位符与参数顺序错位**
//! (SQL 用 `$1`=f_item_type、`$2`=f_item_id,参数却传 `[account, id]`)
//! ⇒ 软删删不掉 ⇒ 关联残留。
//!
//! 🔴 另钉一处**官方形状偏差**:`PermissionGroup` 列表里的 `permissionMember`
//! 官方会用 `userService.getFullNameByIds` 把 id 串换成 **fullName 串**,
//! 本仓必须用子查询做同样的替换,否则前端拿到的是一串 uuid。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例
//! ⇒ 全文件共用一个临时库(`OnceCell`),并用一把进程级 `Mutex` **整体串行化**。
//! 🔴 **不依赖测试执行顺序**:每个测试用自己专属的字段值。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::Value;
use ssw_platform::bootstrap::ensure_base;
use sspf_core::config::Config;
use sspf_core::db::Db;
use sspf_core::seed::first_seed;
use sspf_core::session::{SessionStore, TicketStore};
use sspf_core::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::{Mutex, OnceCell};
/// 全文件共享的临时库。
static DB: OnceCell<Db> = OnceCell::const_new();
/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。
static LOCK: Mutex<()> = Mutex::const_new(());
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
}
/// 起一个真实 HTTP 服务(面 B:请求头带 `Vue-Version: 3`)。
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
}
/// 发一次 HTTP 请求,返回 `(状态行, 响应体 JSON)`。
///
/// 🔴 请求头必须带 `Vue-Version: 3`(面 B 判别头)⇒ 走官方 JNPF 形状。
async fn call(
port: u16,
method: &str,
path: &str,
token: &str,
body: Option<&str>,
) -> (String, Value) {
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(10),
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().unwrap_or_default().to_string();
let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
(status, json)
}
/// 登录拿 token(面 B)。
async fn login(port: u16, account: &str, plain: &str) -> String {
let enc = sspf_core::cipher::encrypt_password(plain);
let payload = format!("account={account}&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(10),
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()
}
/// 造状态(每个测试自己一份 ⇒ token 表互不干扰)。
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch2-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::new()),
tickets: Arc::new(TicketStore::default()),
}
}
/// admin 的用户 id(种子里那个)。
async fn admin_id(db: &Db) -> String {
let rows = db
.query_json(
"SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1",
)
.await
.expect("读 admin 行失败");
rows.first()
.and_then(|r| r["id"].as_str())
.expect("admin 行必须存在")
.to_string()
}
/// 🔴 **Bug ① 的钉子**:`GET /PermissionGroup/PermissionMember/{id}` 必须真的返出成员。
///
/// 曾用 `f_id = ANY($1::text[])` ⇒ pglite-rs 0.2.7 把它当成 PG 数组类型 `_text`
/// ⇒ 协议错 `cannot convert between the Rust type String and the Postgres type _text`
/// ⇒ 接口 500 / `data: null`。
#[tokio::test]
async fn permission_member_list_returns_members() {
let _g = LOCK.lock().await;
let db = db().await;
let port = serve(new_state(db)).await;
let token = login(port, "admin", "123456").await;
// 建一个权限组
let tag = admin_id(db).await;
let (_, res) = call(
port,
"POST",
"/api/permission/PermissionGroup",
&token,
Some(&serde_json::json!({
"fullName": format!("成员组-{tag}"),
"enCode": format!("mgroup-{}", &tag[..8]),
"sortCode": 1,
"description": "回归测试"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建权限组必须成功:{res}");
let pgid = res["data"]["id"]
.as_str()
.expect("建权限组必须返 id")
.to_string();
// 建一个当成员的用户
let acc = format!("b2member-{}", &tag[..8]);
let (_, res) = call(
port,
"POST",
"/api/permission/Users",
&token,
Some(&serde_json::json!({
"account": acc,
"realName": format!("批次2成员-{tag}"),
"password": "123456"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建成员用户必须成功:{res}");
let muid = res["data"]["id"]
.as_str()
.expect("建成员用户必须返 id")
.to_string();
// 存成员
let (_, res) = call(
port,
"POST",
&format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"),
&token,
Some(&serde_json::json!({ "ids": [muid] }).to_string()),
)
.await;
assert_eq!(res["code"], 200, "存权限组成员必须成功:{res}");
// 🔴 核心断言:列表必须真的返出 1 个成员(曾经是 data=null / 500)
let (_, res) = call(
port,
"GET",
&format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"),
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "查权限组成员必须成功:{res}");
let list = res["data"]["list"]
.as_array()
.unwrap_or_else(|| panic!("data.list 必须是数组:{res}"));
assert_eq!(
list.len(),
1,
"权限组必须返 1 个成员(曾经因 $1::text[] 数组类型协议错而 data=null):{res}"
);
assert_eq!(
list[0]["fullName"].as_str(),
Some(format!("批次2成员-{tag}").as_str()),
"成员的 fullName 必须正确:{res}"
);
}
/// 🔴 **Bug ② 的钉子**:`DELETE /PermissionGroup/{id}` 必须成功(不能 500)。
///
/// 软删 `base_authorize` 的 SQL 曾带了 `$1`(删除人)但没用它
/// ⇒ PG 报 `42P18: could not determine data type of parameter $1` ⇒ 500。
#[tokio::test]
async fn permission_group_delete_succeeds() {
let _g = LOCK.lock().await;
let db = db().await;
let port = serve(new_state(db)).await;
let token = login(port, "admin", "123456").await;
let tag = admin_id(db).await;
let (_, res) = call(
port,
"POST",
"/api/permission/PermissionGroup",
&token,
Some(&serde_json::json!({
"fullName": format!("待删组-{tag}"),
"enCode": format!("delgroup-{}", &tag[..8]),
"sortCode": 2,
"description": "回归测试"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建权限组必须成功:{res}");
let pgid = res["data"]["id"]
.as_str()
.expect("建权限组必须返 id")
.to_string();
let (_, res) = call(
port,
"DELETE",
&format!("/api/permission/PermissionGroup/{pgid}"),
&token,
None,
)
.await;
assert_eq!(
res["code"], 200,
"删权限组必须成功(曾经因软删 SQL 里有未使用的 $1 而 500):{res}"
);
// 软删后再查详情必须查不到
let (_, res) = call(
port,
"GET",
&format!("/api/permission/PermissionGroup/{pgid}"),
&token,
None,
)
.await;
assert_eq!(res["code"], 400, "删完后详情必须查不到:{res}");
}
/// 🔴 **Bug ③ 的钉子**:`DELETE /Standing/{id}` 必须把**关联**一起软删干净。
///
/// 曾把 `base_authorize` 软删的占位符与参数顺序搞反(SQL `$1`=f_item_type、`$2`=f_item_id,
/// 参数却传 `[account, id]`)⇒ 关联残留 ⇒ 删完还能在 `/Standing/list` 里看到。
#[tokio::test]
async fn standing_delete_clears_relations() {
let _g = LOCK.lock().await;
let db = db().await;
let port = serve(new_state(db)).await;
let token = login(port, "admin", "123456").await;
// 取一个角色 id 当关联对象
let rows = db
.query_json("SELECT f_id AS \"id\" FROM base_role LIMIT 1")
.await
.expect("读角色失败");
let rid = rows
.first()
.and_then(|r| r["id"].as_str())
.expect("必须有角色")
.to_string();
let tag = admin_id(db).await;
let (_, res) = call(
port,
"POST",
"/api/permission/Standing",
&token,
Some(&serde_json::json!({
"fullName": format!("待删身份-{tag}"),
"enCode": format!("delstand-{}", &tag[..8]),
"sortCode": 3,
"description": "回归测试"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建身份必须成功:{res}");
let sid = res["data"]["id"]
.as_str()
.expect("建身份必须返 id")
.to_string();
// 加一条角色关联
let (_, res) = call(
port,
"POST",
&format!("/api/permission/Standing/{sid}/Actions/AddObject"),
&token,
Some(&serde_json::json!({ "ids": [rid], "type": "role" }).to_string()),
)
.await;
assert_eq!(res["code"], 200, "加关联必须成功:{res}");
// 确认关联在
let (_, res) = call(
port,
"GET",
&format!("/api/permission/Standing/list?id={sid}&type=role"),
&token,
None,
)
.await;
let n = res["data"]["list"].as_array().map(|a| a.len()).unwrap_or(0);
assert_eq!(n, 1, "加完关联应有 1 条:{res}");
// 删身份
let (_, res) = call(
port,
"DELETE",
&format!("/api/permission/Standing/{sid}"),
&token,
None,
)
.await;
assert_eq!(
res["code"],
200,
"删身份必须成功(曾经因软删关联的占位符错位而 500):{res}"
);
// 🔴 核心断言:关联必须也被软删干净
// (`sid` 是我们刚建出来�� uuid ⇒ 直接字面量拼进 SQL,测试专用)
let sql = format!(
"SELECT COUNT(*) AS \"n\" FROM base_authorize \
WHERE f_item_type = 'standing' AND f_item_id = '{sid}' \
AND COALESCE(f_delete_mark,0) = 0"
);
let rows = db.query_json(&sql).await.unwrap_or_else(|e| panic!("回读失败:{e}"));
let alive = rows
.first()
.and_then(|r| r["n"].as_i64())
.unwrap_or(-1);
assert_eq!(
alive, 0,
"删身份后关联必须被软删干净(曾经因占位符与参数顺序错位而残留):{rows:?}"
);
}
/// 判断一个字符串是不是「裸 uuid」(uuid 形状:8-4-4-4-12 全是十六进制)。
///
/// 🔴 不能简单用 `contains('-')` 判断 —— 成员名里也可能带 `-`。
fn is_uuid_like(s: &str) -> bool {
let parts: Vec<&str> = s.split('-').collect();
if parts.len() != 5 {
return false;
}
let lens = [8usize, 4, 4, 4, 12];
parts
.iter()
.zip(lens.iter())
.all(|(p, l)| p.len() == *l && p.chars().all(|c| c.is_ascii_hexdigit()))
}
/// 🔴 **官方形状偏差的钉子**:`PermissionGroup` 列表里的 `permissionMember`
/// 官方会用 `getFullNameByIds` 把 id 串换成 **fullName 串** ⇒ 前端拿到的是人名不是 uuid。
#[tokio::test]
async fn permission_group_list_exposes_member_full_names() {
let _g = LOCK.lock().await;
let db = db().await;
let port = serve(new_state(db)).await;
let token = login(port, "admin", "123456").await;
let tag = admin_id(db).await;
let member_name = format!("名单成员-{tag}");
let (_, res) = call(
port,
"POST",
"/api/permission/Users",
&token,
Some(&serde_json::json!({
"account": format!("listmem-{}", &tag[..8]),
"realName": member_name,
"password": "123456"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建成员必须成功:{res}");
let muid = res["data"]["id"]
.as_str()
.expect("建成员必须返 id")
.to_string();
let (_, res) = call(
port,
"POST",
"/api/permission/PermissionGroup",
&token,
Some(&serde_json::json!({
"fullName": format!("名单组-{tag}"),
"enCode": format!("listgroup-{}", &tag[..8]),
"sortCode": 4,
"description": "回归测试"
}).to_string()),
)
.await;
assert_eq!(res["code"], 200, "建权限组必须成功:{res}");
let pgid = res["data"]["id"]
.as_str()
.expect("建权限组必须返 id")
.to_string();
let (_, res) = call(
port,
"POST",
&format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"),
&token,
Some(&serde_json::json!({ "ids": [muid] }).to_string()),
)
.await;
assert_eq!(res["code"], 200, "存成员必须成功:{res}");
// 读列表,定位本组,看 permissionMember 是人名还是 uuid 串
let (_, res) = call(
port,
"GET",
"/api/permission/PermissionGroup",
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "查权限组列表必须成功:{res}");
let list = res["data"]["list"]
.as_array()
.unwrap_or_else(|| panic!("data.list 必须是数组:{res}"));
let me = list
.iter()
.find(|x| x["id"].as_str() == Some(pgid.as_str()))
.unwrap_or_else(|| panic!("列表里必须能找到刚建的组:{res}"));
let pm = me["permissionMember"].as_str().unwrap_or("");
assert_eq!(
pm,
member_name.as_str(),
"列表里的 permissionMember 必须是**用户名**(官方 getFullNameByIds 的替换),实际={pm:?}"
);
assert!(
!is_uuid_like(pm),
"permissionMember 绝不能是 uuid 串(官方会换成 fullName),实际={pm:?}"
);
}