按官方三源(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 行)。
948 lines
34 KiB
Rust
948 lines
34 KiB
Rust
//! 批次 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}"
|
||
);
|
||
}
|