Files
ssw-platform/src/backend/tests/batch15_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

948 lines
34 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.
//! 批次 15(**系统服务族**)集成测试:
//! `BaseLang`(7) + `Kit`(8) + `CacheManage`(4) + `scheduletask`(7) + `imreply`(3)
//! + `MenuData`(3) + `Variate`(3) + `Monitor`(1) + `HomeData/mySystem`(1) + 三处导出(3)
//! = 39 条端点(另 2 条畸形路径的真实端点早已存在,不在此列),8 张表。
//!
//! 🔴 **钉住的契约点**:
//! ① 多语言是**一行一语种 + `f_group_id` 聚组**:列表按组出一行、`tableHead` 给列定义;
//! `id` 是 **groupId** 不是行 id(前端拿它做详情/更新/删除的键)。
//! ② 套件的 `category` 与批次 14 的控件映射同一个坑:`GET /Kit` 给**分类名称**,
//! `GET /Kit/{id}` 给**分类 id**(编辑表单的 Select 绑的是 id)。
//! ③ 缓存管理在本仓 = **内存会话表**:`name` 形如 `lite:session:<账号>`,
//! 删除**真的**把人踢下线(后续请求 `code=602`),`ClearAll` 保留当前会话。
//! ④ 任务调度**只登记不执行**:`runCount` / `lastRunTime` 恒为表里的真实值(0 / null),
//! `startTime` / `endTime` 是真从 `executeContent` 里提出来的。
//! ⑤ 收藏菜单的判重口径是 `(菜单 id, 我)`;重复收藏必须**明确失败**(不是幂等成功)。
//! ⑥ 公式目录 3 条的数据源是**生成物** `variate_catalog.rs`(35 函数 / 18 变量 /
//! 11 分类),`sysfunctree` 要**排除 `ALL`** 分类。
//! ⑦ 监控是本机**真实**指标(内存/磁盘非零)—— 不是占位 0。
//! ⑧ 三处 `Actions/Export` 一律**明确业务失败**:本仓没有文件服务,
//! 返假 url 会让前端 `downloadByUrl(undefined)` 静默失败(比报错更难查)。
//!
//! 🔴 pglite-rs 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
//! 断言一律按 id / 计数定位,不依赖「列表里只有我造的那几条」。
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
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> 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(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("响应必须有头体分隔");
serde_json::from_str(body.trim()).unwrap_or(Value::Null)
}
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(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()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from(
"/tmp/ssw-platform-batch15-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 起服务 + 登录,返回 (port, token)。
async fn boot() -> (u16, String) {
let (port, token, _state) = boot_with_state().await;
(port, token)
}
/// 同上,但把 `AppState` 也交出去 —— 白盒测试要往会话表里塞**别的账号**的会话。
async fn boot_with_state() -> (u16, String, AppState) {
let state = new_state(db().await);
let port = serve(state.clone()).await;
let token = login(port).await;
(port, token, state)
}
/// 取单值。`value` 为空 ⇒ **不带参数**(SQL 里就不该有 `$1`)。
async fn scalar(sql: &str, value: &str) -> String {
let owned = value.to_string();
let rows = if value.is_empty() {
Db::query_json_params(db().await, sql, &[]).await
} else {
Db::query_json_params(db().await, sql, &[&owned]).await
}
.expect("查询失败");
rows.first()
.and_then(|row| row.as_object())
.and_then(|obj| obj.values().next())
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
}
// ---------------------------------------------------------------- 多语言(BaseLang)
/// ① 列表按**组**出行 + `tableHead` = `code` + 每个语种一列;详情回 `map`;
/// 更新能删掉不给的语种;`enCode` 重复必须失败。
#[tokio::test]
async fn base_lang_is_grouped_by_en_code_and_head_follows_dictionary() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 建一条:两个语种都有值
let res = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.key","type":0,"map":{"zh-CN":"批十五","en-US":"Batch15"}}"#),
)
.await;
assert_eq!(res["code"], 200, "新建翻译必须成功: {res}");
let group_id = res["data"]["id"].as_str().expect("必须回 groupId").to_string();
// 列表:按组出行,`id` 是 groupId,两个语种各占一列
let list = call(port, "GET", "/api/system/BaseLang?keyword=it.batch15", &token, None).await;
assert_eq!(list["code"], 200);
let rows = list["data"]["list"].as_array().expect("必须有 list");
let mine = rows
.iter()
.find(|row| row["id"] == json!(group_id))
.unwrap_or_else(|| panic!("列表里必须按 groupId 出现: {list}"));
assert_eq!(mine["zh-CN"], "批十五", "语种文本必须落在语种列上: {mine}");
assert_eq!(mine["en-US"], "Batch15");
assert_eq!(mine["typeName"], "客户端", "type=0 ⇒ 客户端");
// 表头 = code + 字典里的两个语种(种子来自官方初始库)
let head = list["data"]["tableHead"].as_array().expect("必须有 tableHead");
let props: Vec<&str> = head.iter().filter_map(|h| h["prop"].as_str()).collect();
assert!(props.contains(&"code"), "表头必须有翻译标记列: {props:?}");
assert!(props.contains(&"zh-CN"), "表头必须有 zh-CN 列: {props:?}");
assert!(props.contains(&"en-US"), "表头必须有 en-US 列: {props:?}");
// 详情:`map` 是「语种 -> 文本」
let info = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["enCode"], "it.batch15.key");
assert_eq!(info["data"]["map"]["zh-CN"], "批十五");
assert_eq!(info["data"]["type"], 0);
// 同 enCode 再建一次 ⇒ 必须失败(否则同义标记会有两组)
let dup = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.key","type":0,"map":{"zh-CN":"重复"}}"#),
)
.await;
assert_eq!(dup["code"], 400, "重复翻译标记必须失败: {dup}");
assert_eq!(dup["data"], Value::Null);
// 更新:只给 zh-CN ⇒ en-US 那一行要被删掉
let upd = call(
port,
"PUT",
&format!("/api/system/BaseLang/{group_id}"),
&token,
Some(r#"{"enCode":"it.batch15.key","type":1,"map":{"zh-CN":"批十五改"}}"#),
)
.await;
assert_eq!(upd["code"], 200, "更新必须成功: {upd}");
let info2 = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(info2["data"]["map"]["zh-CN"], "批十五改");
assert!(
info2["data"]["map"].get("en-US").is_none(),
"没给的语种必须被删掉: {info2}"
);
assert_eq!(info2["data"]["type"], 1, "type 要跟着改(服务端)");
// 删除后详情必须 400(不是返回空壳)
let del = call(
port,
"DELETE",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200);
let gone = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(gone["code"], 400, "删掉后详情必须明确失败: {gone}");
}
/// 空 `map` 必须被拒(官方 `SYS052`)—— 否则会建出「有标记没翻译」的空组。
#[tokio::test]
async fn base_lang_rejects_empty_language_map() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.empty","type":0,"map":{"zh-CN":" "}}"#),
)
.await;
assert_eq!(res["code"], 400, "全空白的翻译必须失败: {res}");
}
// ---------------------------------------------------------------- 表单套件(Kit)
/// ② 列表 `category` = 名称,详情 = **id**;复制加 `.副本` 后缀;`Selector` 按分类成树。
#[tokio::test]
async fn kit_list_shows_category_name_but_info_returns_id() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 拿一个真实的业务分类(字典 `businessType` 的某一行)
let category_id = scalar(
"SELECT d.f_id AS \"id\" FROM base_dictionary_data d \
JOIN base_dictionary_type t ON t.f_id = d.f_dictionary_type_id \
WHERE t.f_en_code = 'businessType' ORDER BY d.f_sort_code ASC LIMIT 1",
"",
)
.await;
assert!(!category_id.is_empty(), "businessType 字典必须有数据");
let category_name = scalar(
"SELECT f_full_name AS \"name\" FROM base_dictionary_data WHERE f_id = $1::text",
&category_id,
)
.await;
let created = call(
port,
"POST",
"/api/system/Kit",
&token,
Some(&format!(
r#"{{"fullName":"IT套件","enCode":"it_kit_15","category":"{category_id}","icon":"icon-ym icon-ym-app","formData":"{{\"a\":1}}","enabledMark":1}}"#
)),
)
.await;
assert_eq!(created["code"], 200, "新建套件必须成功: {created}");
let kit_id = created["data"]["id"].as_str().expect("必须回 id").to_string();
let list = call(port, "GET", "/api/system/Kit?keyword=IT套件", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须分页");
let row = rows
.iter()
.find(|r| r["id"] == json!(kit_id))
.unwrap_or_else(|| panic!("列表里必须有刚建的套件: {list}"));
assert_eq!(
row["category"], category_name,
"列表的 category 必须是**分类名称**(不是 id): {row}"
);
assert!(
row.get("formData").is_none(),
"列表不该带 formData(只有详情带): {row}"
);
let info = call(
port,
"GET",
&format!("/api/system/Kit/{kit_id}"),
&token,
None,
)
.await;
assert_eq!(
info["data"]["category"], category_id,
"详情的 category 必须是**真 id**(编辑表单要它): {info}"
);
assert_eq!(info["data"]["formData"], "{\"a\":1}");
// 复制:名称加 `.副本` + 5 位后缀
let copied = call(
port,
"POST",
&format!("/api/system/Kit/{kit_id}/Actions/Copy"),
&token,
None,
)
.await;
assert_eq!(copied["code"], 200, "复制必须成功: {copied}");
let copy_name = scalar(
"SELECT f_full_name AS \"n\" FROM base_visual_kit WHERE f_id = $1::text",
copied["data"]["id"].as_str().unwrap_or_default(),
)
.await;
assert!(
copy_name.starts_with("IT套件.副本") && copy_name.len() > "IT套件.副本".len(),
"副本名必须是 `原名.副本xxxxx`:{copy_name}"
);
// Selector:父节点是分类,子节点是套件
let selector = call(port, "GET", "/api/system/Kit/Selector", &token, None).await;
let roots = selector["data"].as_array().expect("Selector 必须是裸数组");
let parent = roots
.iter()
.find(|node| node["id"] == json!(category_id))
.unwrap_or_else(|| panic!("Selector 必须按分类分组: {selector}"));
assert_eq!(parent["hasChildren"], true);
let children = parent["children"].as_array().expect("分类下必须有子节点");
assert!(
children.iter().any(|c| c["id"] == json!(kit_id)),
"套件必须挂在自己分类下面: {parent}"
);
// 编码查重(同 enCode 再来一个必须失败)
let dup = call(
port,
"POST",
"/api/system/Kit",
&token,
Some(&format!(
r#"{{"fullName":"IT套件2","enCode":"it_kit_15","category":"{category_id}","icon":"x"}}"#
)),
)
.await;
assert_eq!(dup["code"], 400, "套件编码重复必须失败: {dup}");
}
// ---------------------------------------------------------------- 缓存管理(CacheManage)
/// ③ 缓存 = 内存会话:列得出、删得掉(**真的**踢下线)、`ClearAll` 保留当前会话。
#[tokio::test]
async fn cache_manage_lists_sessions_and_delete_really_revokes() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let list = call(port, "GET", "/api/system/CacheManage", &token, None).await;
assert_eq!(list["code"], 200, "缓存列表必须成功: {list}");
let rows = list["data"]["list"].as_array().expect("必须分页");
let mine = rows
.iter()
.find(|r| r["name"] == "lite:session:admin")
.unwrap_or_else(|| panic!("在线会话必须出现在缓存列表里: {list}"));
assert!(
mine["cacheSize"].as_i64().unwrap_or(0) > 0,
"缓存大小必须是真实字节数: {mine}"
);
assert_eq!(mine["overdueTime"], Value::Null, "会话不过期 ⇒ null");
// 详情:`value` 是 JSON 字符串(官方 `JSON.toJSONString`)
let info = call(
port,
"GET",
"/api/system/CacheManage/lite:session:admin",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "缓存详情必须成功: {info}");
let value: Value = serde_json::from_str(info["data"]["value"].as_str().unwrap_or_default())
.expect("value 必须是 JSON 字符串");
assert_eq!(value["account"], "admin");
assert!(
!info["data"]["value"]
.as_str()
.unwrap_or_default()
.contains(&token),
"🔴 详情里绝不能出现 token 本身"
);
// 删掉 admin 的会话 ⇒ 同一个 token 立刻失效(602)
let del = call(
port,
"DELETE",
"/api/system/CacheManage/lite:session:admin",
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删除缓存必须成功: {del}");
assert!(
del["data"]["removed"].as_i64().unwrap_or(0) >= 1,
"至少要删掉一条会话: {del}"
);
let after = call(port, "GET", "/api/system/BaseLang", &token, None).await;
assert_eq!(
after["code"], 602,
"会话被清掉后必须掉线(602),不是继续放行: {after}"
);
}
/// ③ `ClearAll` 保留当前操作者的会话(对齐官方「跳过 token 前缀的键」)。
#[tokio::test]
async fn cache_manage_clear_all_keeps_operator_session() {
let _guard = LOCK.lock().await;
let (port, token, state) = boot_with_state().await;
// 白盒塞一条**别的账号**的会话:`ClearAll` 要清它、但不能清操作者自己。
let outsider = state.sessions.issue("it-batch15-outsider", "uid-outsider", 0);
let cleared = call(
port,
"POST",
"/api/system/CacheManage/Actions/ClearAll",
&token,
None,
)
.await;
assert_eq!(cleared["code"], 200, "清空缓存必须成功: {cleared}");
assert!(
cleared["data"]["removed"].as_i64().unwrap_or(0) >= 1,
"至少清掉 outsider 那一条: {cleared}"
);
let mine = call(port, "GET", "/api/system/BaseLang", &token, None).await;
assert_eq!(mine["code"], 200, "操作者自己不能被踢下线: {mine}");
let other = call(port, "GET", "/api/system/BaseLang", &outsider, None).await;
assert_eq!(other["code"], 602, "别的账号的会话必须被清掉: {other}");
}
// ---------------------------------------------------------------- 任务调度(scheduletask)
/// ④ 只登记不执行:`runCount=0`、`lastRunTime=null`、`startTime` 从 `executeContent` 提出。
#[tokio::test]
async fn scheduled_task_registers_without_pretending_to_run() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let created = call(
port,
"POST",
"/api/scheduletask",
&token,
Some(
r#"{"fullName":"IT任务","enCode":"it_task_15","executeType":1,"enabledMark":1,
"executeContent":{"cron":"0 0 1 * * ?","startTime":1700000000000,"endTime":1800000000000,"interfaceId":"x"}}"#,
),
)
.await;
assert_eq!(created["code"], 200, "新建任务必须成功: {created}");
let task_id = created["data"]["id"].as_str().expect("必须回 id").to_string();
let list = call(port, "GET", "/api/scheduletask?keyword=it_task_15", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须分页");
let row = rows
.iter()
.find(|r| r["id"] == json!(task_id))
.unwrap_or_else(|| panic!("列表里必须有刚建的任务: {list}"));
assert_eq!(row["runCount"], 0, "没有调度器 ⇒ 执行次数恒 0: {row}");
assert_eq!(
row["lastRunTime"],
Value::Null,
"没跑过就不能编一个最后执行时间: {row}"
);
assert_eq!(row["startTime"], 1700000000000_i64, "startTime 要从 executeContent 提上来: {row}");
assert_eq!(row["endTime"], 1800000000000_i64);
assert_eq!(row["executeContent"]["cron"], "0 0 1 * * ?");
// 详情:`executeContent` 是**对象**(表单要 `.cron` 这么绑)
let info = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["executeContent"]["cron"], "0 0 1 * * ?");
assert_eq!(info["data"]["enCode"], "it_task_15");
// 日志:没有执行就没有日志(空列表,不是报错)
let logs = call(
port,
"GET",
&format!("/api/scheduletask/{task_id}/TaskLog"),
&token,
None,
)
.await;
assert_eq!(logs["code"], 200, "任务日志必须能查: {logs}");
assert_eq!(
logs["data"]["list"].as_array().map(Vec::len),
Some(0),
"没执行过就不该有日志: {logs}"
);
// `TaskMethods`:没有执行器 ⇒ 空清单(返错会让新建表单整体红条)
let methods = call(port, "GET", "/api/scheduletask/TaskMethods", &token, None).await;
assert_eq!(methods["code"], 200, "TaskMethods 必须成功: {methods}");
assert_eq!(methods["data"]["list"].as_array().map(Vec::len), Some(0));
// 编码查重
let dup = call(
port,
"POST",
"/api/scheduletask",
&token,
Some(r#"{"fullName":"IT任务2","enCode":"it_task_15"}"#),
)
.await;
assert_eq!(dup["code"], 400, "任务编码重复必须失败: {dup}");
// 改 → 删
let upd = call(
port,
"PUT",
&format!("/api/scheduletask/{task_id}"),
&token,
Some(r#"{"fullName":"IT任务改","enabledMark":0}"#),
)
.await;
assert_eq!(upd["code"], 200, "更新必须成功: {upd}");
let after = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(after["data"]["fullName"], "IT任务改");
assert_eq!(after["data"]["enabledMark"], 0);
assert_eq!(
after["data"]["executeContent"]["cron"], "0 0 1 * * ?",
"没改 executeContent ⇒ 原值不能丢"
);
let del = call(
port,
"DELETE",
&format!("/api/scheduletask/{task_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删除必须成功: {del}");
let gone = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(gone["code"], 400, "删掉后详情必须明确失败: {gone}");
}
// ---------------------------------------------------------------- 常用菜单(MenuData)
/// ⑤ 收藏 → 列表可见;重复收藏**明确失败**;取消收藏后列表里消失。
#[tokio::test]
async fn menu_data_favorite_is_user_scoped_and_not_idempotent() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let menu_id = scalar(
"SELECT f_id AS \"id\" FROM base_module WHERE f_en_code = 'permission.user' LIMIT 1",
"",
)
.await;
assert!(!menu_id.is_empty(), "种子菜单 permission.user 必须存在");
let created = call(
port,
"POST",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(created["code"], 200, "收藏必须成功: {created}");
let list = call(port, "GET", "/api/system/MenuData", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须是 {list}");
let row = rows
.iter()
.find(|r| r["id"] == json!(menu_id))
.unwrap_or_else(|| panic!("收藏的菜单必须在列表里: {list}"));
assert_eq!(row["enCode"], "permission.user");
assert!(
row["systemCode"].as_str().unwrap_or_default().len() > 0,
"systemCode 要从 base_system 带出来: {row}"
);
let dup = call(
port,
"POST",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(dup["code"], 400, "重复收藏必须明确失败: {dup}");
let del = call(
port,
"DELETE",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "取消收藏必须成功: {del}");
let after = call(port, "GET", "/api/system/MenuData", &token, None).await;
assert!(
!after["data"]["list"]
.as_array()
.map(|rows| rows.iter().any(|r| r["id"] == json!(menu_id)))
.unwrap_or(false),
"取消收藏后不该再出现: {after}"
);
// 不存在的菜单 ⇒ 400(不是静默插入一条指向空菜单的收藏)
let ghost = call(
port,
"POST",
"/api/system/MenuData/not-a-menu",
&token,
None,
)
.await;
assert_eq!(ghost["code"], 400, "收藏不存在的菜单必须失败: {ghost}");
}
// ---------------------------------------------------------------- 公式目录(Variate 补 3 条)
/// ⑥ 18 条系统变量 / 按分类取函数 / 函数树排除 `ALL`。
#[tokio::test]
async fn variate_catalog_serves_functions_and_system_variates() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let variates = call(port, "GET", "/api/system/Variate/sysvariate", &token, None).await;
assert_eq!(variates["code"], 200);
let items = variates["data"]["list"].as_array().expect("必须是 {list}");
assert_eq!(items.len(), 18, "官方 `SystemVariateEnum` 是 18 条: {items:?}");
assert!(
items.iter().any(|v| v["field"] == "@userId"),
"必须含 @userId"
);
// 按分类取函数:`type` 与 `?category=` 都认
let math = call(
port,
"GET",
"/api/system/Variate/MATH/sysfunc?category=MATH",
&token,
None,
)
.await;
let funcs = math["data"].as_array().expect("sysfunc 的 data 是**裸数组**");
assert!(!funcs.is_empty(), "数学函数不该是空的: {math}");
assert!(
funcs.iter().all(|f| f["subCategory"] == "数学函数"),
"同一个分类下的函数 subCategory 必须一致: {funcs:?}"
);
assert!(
funcs.iter().any(|f| f["field"] == "SUM"),
"数学函数里必须有 SUM"
);
// 未知分类 ⇒ 空数组(不是报错)
let unknown = call(port, "GET", "/api/system/Variate/NOPE/sysfunc", &token, None).await;
assert_eq!(unknown["code"], 200);
assert_eq!(unknown["data"].as_array().map(Vec::len), Some(0));
// 函数树:父节点是分类(**不含 ALL**),子节点是函数
let tree = call(port, "GET", "/api/system/Variate/sysfunctree", &token, None).await;
let roots = tree["data"]["list"].as_array().expect("必须是 {list}");
assert!(!roots.is_empty(), "函数树不该是空的: {tree}");
assert!(
!roots.iter().any(|node| node["field"] == "ALL"),
"`ALL` 不是真分类,必须被排除: {tree}"
);
let root = &roots[0];
assert_eq!(root["parentId"], "0");
assert_eq!(root["hasChildren"], true);
let children = root["children"].as_array().expect("父节点必须有 children");
assert!(!children.is_empty());
assert_eq!(
children[0]["parentId"], root["id"],
"子节点的 parentId 必须指回父节点 id"
);
assert_eq!(
children[0]["expression"], children[0]["field"],
"函数的 expression 就是函数名"
);
}
// ---------------------------------------------------------------- 监控 / 我的应用 / 导出
/// ⑦ 监控是**真实**指标:内存与磁盘非零、比例在 0..=100。
#[tokio::test]
async fn monitor_reports_real_host_metrics() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/system/Monitor", &token, None).await;
assert_eq!(res["code"], 200, "监控必须成功: {res}");
let data = &res["data"];
assert_ne!(
data["memory"]["total"], "0 B",
"内存总量必须是真值(占位 0 视为失败): {data}"
);
assert_ne!(
data["disk"]["total"], "0 B",
"磁盘总量必须是真值: {data}"
);
let rate = data["memory"]["usageRate"]
.as_str()
.unwrap_or_default()
.parse::<f64>()
.expect("usageRate 必须是两位小数字符串");
assert!((0.0..=100.0).contains(&rate), "使用率必须在 0..=100: {rate}");
assert!(
data["cpu"]["used"].is_string(),
"CPU 使用率必须是字符串(前端按 `'0.00'` 判零): {data}"
);
assert!(
data["time"].as_i64().unwrap_or(0) > 0,
"时间戳必须是真的: {data}"
);
}
/// ⑨ 我的应用 = 授权应用(排除主系统),`data` 是裸数组。
#[tokio::test]
async fn home_my_system_excludes_main_system() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/system/HomeData/mySystem", &token, None).await;
assert_eq!(res["code"], 200, "我的应用必须成功: {res}");
let list = res["data"].as_array().expect("data 必须是**裸数组**");
assert!(!list.is_empty(), "种子里有 app-b ⇒ 至少一个非主系统: {res}");
assert!(
list.iter().all(|s| s["isTop"].is_boolean()),
"每一项都要有 isTop(前端置顶排序用): {list:?}"
);
}
/// ⑧ 三处 `Actions/Export` 一律明确业务失败(本仓无文件服务)。
#[tokio::test]
async fn export_endpoints_refuse_instead_of_returning_a_fake_url() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
for path in [
"/api/system/Kit/any-id/Actions/Export",
"/api/system/System/any-id/Actions/Export",
"/api/system/Tag/any-id/Actions/Export",
] {
let res = call(port, "GET", path, &token, None).await;
assert_eq!(res["code"], 400, "{path} 必须明确失败: {res}");
assert_eq!(res["data"], Value::Null, "{path} 不能返假 url: {res}");
assert!(
res["msg"].as_str().unwrap_or_default().contains("文件服务"),
"{path} 的失败原因必须是「没有文件服务」: {res}"
);
}
}
// ---------------------------------------------------------------- IM 会话(imreply)
/// ⑥ 会话列表的未读数 / 最新消息都从 `base_im_content` **真算**;
/// 删聊天记录只删双方之间的消息,移除会话只动 `base_im_reply`。
#[tokio::test]
async fn im_reply_derives_unread_and_latest_from_content() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 造数据:admin ↔ 另一个用户的两条消息(一条未读)
// 🔴 种子库只有 `admin` 一个用户,会话列表要 `JOIN base_user` 才出对方名字 ⇒
// 必须自己补一个**启用未删除**的对方,否则列表里根本不会出现这条会话。
// 全文件共用同一个临时库 ⇒ 用固定 id + `ON CONFLICT DO NOTHING` 保证可重跑。
let admin_id = scalar(
"SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1",
"",
)
.await;
Db::exec_params(
db().await,
"INSERT INTO base_user (f_id, f_account, f_real_name, f_enabled_mark, \
f_delete_mark, f_tenant_id, f_creator_time) \
VALUES ('it-batch15-peer', 'itpeer', '对话对端', 1, 0, '0', now()) \
ON CONFLICT (f_id, f_tenant_id) DO NOTHING",
&[],
)
.await
.expect("造第二个用户失败");
let peer_id = scalar(
"SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'itpeer' LIMIT 1",
"",
)
.await;
assert!(
!admin_id.is_empty() && !peer_id.is_empty(),
"至少要两个用户(admin={admin_id}, peer={peer_id})"
);
for sql in [
format!(
"INSERT INTO base_im_reply (f_id, f_user_id, f_receive_user_id, f_receive_time, \
f_delete_mark, f_tenant_id, f_creator_time) \
VALUES ('it-im-reply-1', '{admin_id}', '{peer_id}', now(), 0, '0', now())"
),
format!(
"INSERT INTO base_im_content (f_id, f_send_user_id, f_receive_user_id, f_content, \
f_content_type, f_send_time, f_delete_mark, f_tenant_id) \
VALUES ('it-im-content-1', '{peer_id}', '{admin_id}', '你好', 'text', now(), 0, '0')"
),
] {
Db::exec_params(db().await, &sql, &[]).await.expect("造 IM 数据失败");
}
let res = call(port, "GET", "/api/message/imreply", &token, None).await;
assert_eq!(res["code"], 200, "会话列表必须成功: {res}");
let rows = res["data"]["list"].as_array().expect("必须是 {list}");
let conv = rows
.iter()
.find(|r| r["id"] == json!(peer_id))
.unwrap_or_else(|| panic!("必须出现与 peer 的会话: {res}"));
assert_eq!(conv["unreadMessage"], 1, "未读数要从 content 真算: {conv}");
assert_eq!(conv["latestMessage"], "你好");
// 删聊天记录:只删两人之间的消息
let del = call(
port,
"DELETE",
&format!("/api/message/imreply/deleteChatRecord/{peer_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删聊天记录必须成功: {del}");
let after = call(port, "GET", "/api/message/imreply", &token, None).await;
let conv2 = after["data"]["list"]
.as_array()
.and_then(|rows| rows.iter().find(|r| r["id"] == json!(peer_id)).cloned())
.expect("会话本身还在(只删了消息)");
assert_eq!(conv2["unreadMessage"], 0, "消息删了未读就该归零: {conv2}");
// 移除会话:只动 base_im_reply
let relocated = call(
port,
"DELETE",
&format!("/api/message/imreply/relocation/{peer_id}"),
&token,
None,
)
.await;
assert_eq!(relocated["code"], 200, "移除会话必须成功: {relocated}");
let gone = call(port, "GET", "/api/message/imreply", &token, None).await;
assert!(
!gone["data"]["list"]
.as_array()
.map(|rows| rows.iter().any(|r| r["id"] == json!(peer_id)))
.unwrap_or(false),
"移除后不该再出现: {gone}"
);
}