Files
ssw-platform/src/backend/tests/batch4_it.rs
T
admin 1c224b7b79 feat(core): 补齐 core 族 22 条端点并同步契约三处
按官方三源(LoginController / UtilsController / LocationController +
官方前端 api/core/*.ts)逐条核对,实现 22 条 core 端点:
- 真实现 6 条:锁屏解锁、免密登录票据、扫码凭证状态流转
- 诚实失败 16 条:文件族 4 + 导入族 4 + 地图族 3 + 改密通知 1
  + SaaS 族 3 + socials 1(无文件存储 / 无导入引擎 / 无地图服务 /
  无邮件短信通道 / 无多租户切库 / 无第三方账号 ⇒ code=400 + 人话,
  不返假 URL、不返假坐标)

新增 TicketStore(进程内内存票据表,官方用 Redis 而本仓无 Redis):
两种票据带前缀隔离(tkt- / scc-),不互相串用。

同批修掉一个真偏差:Login/saas 原先写成 let _ = require_login_face_b(..)
丢弃了 Err ⇒ 实际不拦,但静态闸门推成「登录」⇒ 契约标签与运行时行为
不符;已改成真拦(官方 TenantSaasGranter.checkTenantUser 要求已有登录态)。

契约三处同步:[ENDPOINT] +22 / [OFFICIAL] +22 / [FACE] 面 B 558→580,
并顺手修正契约 §6 头两个无人校验的散文数字(132→610 条、53→607 行)。
2026-11-02 17:34:03 +08:00

637 lines
20 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.
//! 批次 4(业务分类 `/api/system/BusinessCategory` + 站内消息 `/api/message` + 公告)集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方 VO / 控制器的一处要求):
//! ① `GET /BusinessCategory` 是 `ListVO` 且 `list` 是**树**(根节点带 `children`);
//! `?treeList?type=1` 只剩一级(5 条),`type=2` 带一层子级,`selector?parentId=-1`
//! 是「**所有一级的子级**」(官方 `getListByParentIds(["-1"])` 的两段式语义)。
//! ② 平台种子必须真灌进库:5 个一级 + 33 个二级 = 38 行
//! (`platform/seed.rs::BUSINESS_CATEGORIES`,官方初始库同源)。
//! ③ `POST /message/Notice` 只是**草稿**(`enabledMark=0`);`PUT …/Actions/Release`
//! 才置 1 并**给每个收件人各落一条 `base_message`** —— 这是「消息记录页有东西」的唯一来源。
//! ④ 落库的消息:`f_type=1`、`enCode=announce`、`typeName=公告`、
//! `f_category` 同时含一级与二级分类 id ⇒ 页签按二级过滤、类型名按一级解析,两者都成立。
//! ⑤ `GET /message/ReadInfo/{id}` **会写库**(`isRead` 0 ⇒ 1),且把公告快照 JSON 摊平。
//! ⑥ `POST /message/Reply/{id}` ⇒ `isRead = 2`(已回执),**不回退**成 1。
//! ⑦ `DELETE /message/Record` 只删**自己的**消息,且是软删(列表 total 归零)。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::bootstrap::ensure_base;
use ssw_platform::platform::config::Config;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::{SessionStore, TicketStore};
use ssw_platform::platform::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
}
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
}
/// 面 B 请求(带 `Vue-Version: 3`)。
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)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&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()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch4-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 建一条公告并发布,返回 `(公告 id, 标题)`。收件人为空 ⇒ 发给全体用户。
async fn seed_notice(port: u16, token: &str, title: &str) -> String {
let body = json!({
"title": title,
"bodyText": "<p>正文<b>加粗</b>部分</p>",
"category": "notice_type_1",
"replyType": 1,
});
let (_, created) = call(
port,
"POST",
"/api/message/Notice",
token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建公告失败: {created}");
let (_, listed) = call(
port,
"POST",
"/api/message/Notice/List",
token,
Some(&json!({ "keyword": title }).to_string()),
)
.await;
assert_eq!(listed["code"], 200, "公告列表失败: {listed}");
let row = listed["data"]["list"]
.as_array()
.expect("data 必须是 PageListVO")
.iter()
.find(|x| x["title"] == json!(title))
.unwrap_or_else(|| panic!("新建的公告必须出现在列表: {listed}"))
.clone();
let id = row["id"].as_str().expect("公告必须有 id").to_string();
// ③ 草稿状态:新建不发布 ⇒ enabledMark=0。
assert_eq!(row["enabledMark"], json!(0), "新建的公告应是草稿: {row}");
id
}
/// 业务分类:种子行数 / 树形状 / type 裁剪 / selector 两段式 / CRUD 判重。
#[tokio::test]
async fn business_category_tree_and_crud() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 一级:5 条(应用 / 流程 / 系统 / 公告 / 其他)。
let (_, lv1) = call(
port,
"GET",
"/api/system/BusinessCategory/treeList?type=1",
&token,
None,
)
.await;
assert_eq!(lv1["code"], 200, "{lv1}");
let roots = lv1["data"]["list"].as_array().expect("data 必须是 ListVO");
assert_eq!(roots.len(), 5, "一级分类必须是 5 个: {lv1}");
let names: Vec<&str> = roots.iter().filter_map(|x| x["fullName"].as_str()).collect();
assert_eq!(names, vec!["应用", "流程", "系统", "公告", "其他"], "{lv1}");
assert!(
roots.iter().all(|x| x.get("children").is_none()),
"type=1 不该带子级: {lv1}"
);
// ① type=2 ⇒ 带一层子级;流程下必须是 24 个(官方二级 + 新增的「消息通知」)。
let (_, lv2) = call(
port,
"GET",
"/api/system/BusinessCategory/treeList?type=2",
&token,
None,
)
.await;
let roots2 = lv2["data"]["list"].as_array().unwrap();
assert_eq!(roots2.len(), 5, "{lv2}");
let flow = roots2
.iter()
.find(|x| x["enCode"] == json!("flow"))
.expect("必须有流程一级");
let flow_children = flow["children"].as_array().expect("type=2 必须带子级");
assert!(!flow_children.is_empty(), "流程下必须有二级: {flow}");
assert_eq!(
flow["hasChildren"],
json!(true),
"有子级时 hasChildren 必须是 true: {flow}"
);
// ① selector `parentId=-1` = **所有一级的子级**(33 条种子二级)。
let (_, sel_all) = call(
port,
"GET",
"/api/system/BusinessCategory/selector?parentId=-1",
&token,
None,
)
.await;
let all_level2 = sel_all["data"]["list"].as_array().unwrap();
assert_eq!(
all_level2.len(),
33,
"种子二级分类应为 33 个: {}",
sel_all
);
// ① selector `parentId=<一级 id>` = 该一级的直接子级。
let flow_id = flow["id"].as_str().unwrap().to_string();
let (_, sel_flow) = call(
port,
"GET",
&format!("/api/system/BusinessCategory/selector?parentId={flow_id}"),
&token,
None,
)
.await;
let flow_children2 = sel_flow["data"]["list"].as_array().unwrap();
assert_eq!(
flow_children2.len(),
flow_children.len(),
"selector 与 treeList 的子级数必须一致"
);
// ② 全树接口 `GET /BusinessCategory` 的 `list` 同样是树(不是平铺 38 行)。
let (_, tree) = call(port, "GET", "/api/system/BusinessCategory", &token, None).await;
assert_eq!(
tree["data"]["list"].as_array().unwrap().len(),
5,
"全树接口返回的必须是根节点: {tree}"
);
// ④ 新建 → 同父级重名 400 → 编码重复 400 → 改 → 删。
let other_id = roots
.iter()
.find(|x| x["enCode"] == json!("other"))
.expect("必须有其他一级")["id"]
.as_str()
.unwrap()
.to_string();
let body = json!({ "fullName": "批次四分类", "parentId": other_id, "enCode": "ZDY9" });
let (_, created) = call(
port,
"POST",
"/api/system/BusinessCategory",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建分类失败: {created}");
let (_, dup_name) = call(
port,
"POST",
"/api/system/BusinessCategory",
&token,
Some(&json!({ "fullName": "批次四分类", "parentId": other_id }).to_string()),
)
.await;
assert_eq!(dup_name["code"], 400, "同层级重名必须 400: {dup_name}");
let (_, dup_code) = call(
port,
"POST",
"/api/system/BusinessCategory",
&token,
Some(&json!({ "fullName": "批次四分类2", "parentId": other_id, "enCode": "ZDY9" }).to_string()),
)
.await;
assert_eq!(dup_code["code"], 400, "编码重复必须 400: {dup_code}");
let (_, under_other) = call(
port,
"GET",
&format!("/api/system/BusinessCategory/selector?parentId={other_id}"),
&token,
None,
)
.await;
let row = under_other["data"]["list"]
.as_array()
.unwrap()
.iter()
.find(|x| x["fullName"] == json!("批次四分类"))
.expect("新建的分类必须出现在父级下拉里")
.clone();
let cid = row["id"].as_str().unwrap().to_string();
assert_eq!(row["type"], json!(1), "新建分类的 f_type 必须是 1(官方同款): {row}");
let (_, renamed) = call(
port,
"PUT",
&format!("/api/system/BusinessCategory/{cid}"),
&token,
Some(&json!({ "fullName": "批次四分类改名" }).to_string()),
)
.await;
assert_eq!(renamed["code"], 200, "{renamed}");
let (_, info) = call(
port,
"GET",
&format!("/api/system/BusinessCategory/{cid}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["fullName"], json!("批次四分类改名"), "{info}");
assert_eq!(info["data"]["enCode"], json!("ZDY9"), "改名不该动编码: {info}");
let (_, deleted) = call(
port,
"DELETE",
&format!("/api/system/BusinessCategory/{cid}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "{deleted}");
let (_, gone) = call(
port,
"GET",
&format!("/api/system/BusinessCategory/{cid}"),
&token,
None,
)
.await;
assert_eq!(gone["code"], 400, "软删后详情必须查不到: {gone}");
}
/// 公告发布 ⇒ 真的给收件人落站内消息(消息记录页的数据来源)。
#[tokio::test]
async fn notice_release_fans_out_messages() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let title = "发布扩散用例";
let id = seed_notice(port, &token, title).await;
// 未发布前,消息记录页应为空(这条用例自己创造消息,先清零自己的)。
let (_, before) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
assert_eq!(
before["data"]["pagination"]["total"],
json!(0),
"草稿公告不该产生消息: {before}"
);
let (_, released) = call(
port,
"PUT",
&format!("/api/message/Notice/{id}/Actions/Release"),
&token,
Some("{}"),
)
.await;
assert_eq!(released["code"], 200, "发布失败: {released}");
// ② 公告本体已发送。
let (_, notices) = call(
port,
"POST",
"/api/message/Notice/List",
&token,
Some(&json!({ "keyword": title }).to_string()),
)
.await;
let notice = &notices["data"]["list"][0];
assert_eq!(notice["enabledMark"], json!(1), "发布后必须是已发送: {notices}");
assert!(
notice["releaseUser"].as_str().map(|s| !s.is_empty()).unwrap_or(false),
"发布后 releaseUser 必须有值: {notices}"
);
// ④ 消息列表出现,且形状对得上消息记录页(title/type/isRead/releaseUser/enCode)。
let (_, msgs) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
assert_eq!(msgs["code"], 200, "{msgs}");
assert_eq!(
msgs["data"]["pagination"]["total"],
json!(1),
"发布后必须给 admin 落 1 条消息: {msgs}"
);
let msg = &msgs["data"]["list"][0];
assert_eq!(msg["title"], json!(title), "{msg}");
assert_eq!(msg["type"], json!(1), "公告类消息 type 必须是 1: {msg}");
assert_eq!(msg["typeName"], json!("公告"), "{msg}");
assert_eq!(msg["enCode"], json!("announce"), "{msg}");
assert_eq!(msg["isRead"], json!(0), "新消息必须未读: {msg}");
assert!(
msg["releaseUser"].as_str().map(|s| s.contains('/')).unwrap_or(false),
"releaseUser 应是「姓名/账号」: {msg}"
);
assert!(
msg["releaseTime"].as_i64().unwrap_or(0) > 0,
"releaseTime 必须是毫秒时间戳: {msg}"
);
// ④ 二级页签过滤:公告提醒 ⇒ 命中;流程的某个二级 ⇒ 不命中。
let (_, by_announce) = call(
port,
"GET",
&format!("/api/message?keyword={title}&category=2046498549667074048"),
&token,
None,
)
.await;
assert_eq!(
by_announce["data"]["pagination"]["total"],
json!(1),
"按「公告提醒」二级页签必须能查到: {by_announce}"
);
let (_, by_flow) = call(
port,
"GET",
&format!("/api/message?keyword={title}&category=2046500072862126080"),
&token,
None,
)
.await;
assert_eq!(
by_flow["data"]["pagination"]["total"],
json!(0),
"按流程二级页签不该查到公告消息: {by_flow}"
);
}
/// 读消息(置已读 + 摊平快照)/ 回执(isRead=2)/ 只有自己能看到并删除。
#[tokio::test]
async fn message_read_reply_and_delete() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let title = "读回执用例";
let notice_id = seed_notice(port, &token, title).await;
let (_, released) = call(
port,
"PUT",
&format!("/api/message/Notice/{notice_id}/Actions/Release"),
&token,
Some("{}"),
)
.await;
assert_eq!(released["code"], 200, "{released}");
let (_, msgs) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
let mid = msgs["data"]["list"][0]["id"]
.as_str()
.expect("消息必须有 id")
.to_string();
// ⑤ 读一次:isRead 0 ⇒ 1,且公告快照里的 bodyText 被摊平到 VO 上。
let (_, read) = call(
port,
"GET",
&format!("/api/message/ReadInfo/{mid}"),
&token,
None,
)
.await;
assert_eq!(read["code"], 200, "{read}");
assert_eq!(read["data"]["isRead"], json!(1), "读一次必须置已读: {read}");
assert_eq!(
read["data"]["bodyText"], json!("<p>正文<b>加粗</b>部分</p>"),
"公告快照的正文必须摊平到 VO: {read}"
);
assert_eq!(read["data"]["title"], json!(title), "{read}");
let (_, again) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
assert_eq!(
again["data"]["list"][0]["isRead"],
json!(1),
"已读必须落库(不是只改返回值): {again}"
);
// ⑥ 回执 ⇒ isRead = 2;再读一次**不回退**成 1。
let (_, replied) = call(
port,
"POST",
&format!("/api/message/Reply/{mid}"),
&token,
None,
)
.await;
assert_eq!(replied["code"], 200, "{replied}");
let (_, after_reply) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
assert_eq!(
after_reply["data"]["list"][0]["isRead"],
json!(2),
"回执后必须是 2: {after_reply}"
);
let (_, reread) = call(
port,
"GET",
&format!("/api/message/ReadInfo/{mid}"),
&token,
None,
)
.await;
assert_eq!(
reread["data"]["isRead"],
json!(2),
"再读一次不能把已回执降回已读: {reread}"
);
// 回执人员列表里必须出现 admin。
let (_, reply_users) = call(
port,
"GET",
&format!("/api/message/Notice/{notice_id}/ReplyUserList"),
&token,
None,
)
.await;
assert_eq!(reply_users["code"], 200, "{reply_users}");
let users = reply_users["data"]["list"].as_array().unwrap();
assert_eq!(users.len(), 1, "回执人员应只有 admin: {reply_users}");
assert!(
users[0]["replyUser"]
.as_str()
.map(|s| s.contains('/'))
.unwrap_or(false),
"回执人应是「姓名/账号」: {reply_users}"
);
// ⑦ 删除自己的消息 ⇒ 列表 total 归零。
let (_, removed) = call(
port,
"DELETE",
"/api/message/Record",
&token,
Some(&json!({ "ids": mid }).to_string()),
)
.await;
assert_eq!(removed["code"], 200, "删除消息失败: {removed}");
let (_, after_delete) = call(
port,
"GET",
&format!("/api/message?keyword={title}"),
&token,
None,
)
.await;
assert_eq!(
after_delete["data"]["pagination"]["total"],
json!(0),
"删除后不该再出现: {after_delete}"
);
// 空 ids 删除 ⇒ 400(官方 `MessageRecordForm` 校验失败的表现)。
let (_, empty) = call(
port,
"DELETE",
"/api/message/Record",
&token,
Some(&json!({}).to_string()),
)
.await;
assert_eq!(empty["code"], 400, "空 ids 必须 400: {empty}");
}