//! 批次 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 = 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::() .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}" ); }