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

655 lines
24 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.
//! 批次 5(系统日志 `/api/system/Log` + 审批常用语 `/api/system/CommonWords` +
//! 单据规则 `/api/system/BillRule`)集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / mapper 的一处硬要求):
//! ① `GET /Log?category=1` 是 `PageListVO`,`creatorTime` 是**毫秒数**(官方 VO 是 `Long`);
//! `category=2`(访问日志)官方走 `default` ⇒ **必须 400**,不是空列表。
//! ② 登录**会落 `base_sys_log`**(`f_type=1`):`loginMark=1`、`browser`/`platForm` 从 UA 粗分
//! ⇒ 个人中心 `Users/Current/SystemLog` 才有内容(早先恒空、也不报错)。
//! ③ `DELETE /Log/{type}` 按**分类**清空(`type` 是分类号不是 id),
//! `DELETE /Log/deleteLoginLog` 只清**自己的** —— 两条语义不同,不能合并。
//! ④ 常用语:`text + type` 同档判重(`SYS105`)、`UsesNum` 按**文本**累加。
//! ⑤ 单据规则的单号生成三分支 + **跨天归零**:上一号的日期段 ≠ 今天 ⇒ 从 0 重来。
//! ⑥ 已发过号的规则**不许删**(`SYS003`);导出/导入本仓无文件服务 ⇒ 明确 400。
//!
//! 🔴 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::{pglite::ToSql, 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)
}
/// 登录(**带 User-Agent**:登录日志的「浏览器 / 操作系统」两列靠它)。
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\
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 \
(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36\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-batch5-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 取「今天」的 `YYYYMMDD`(与后端 `to_char(now(), 'YYYYMMDD')` 同一来源:库里算)。
async fn today_ymd(db: &Db) -> String {
let rows = db
.query_json_params("SELECT to_char(now(), 'YYYYMMDD') AS \"d\"", &[])
.await
.expect("取日期失败");
rows[0]["d"].as_str().unwrap_or_default().to_string()
}
// ---------------------------------------------------------------- 系统日志
/// 登录落库 ⇒ `/api/system/Log` 与个人中心「登录日志」都看得到同一条。
#[tokio::test]
async fn login_writes_log_and_both_readers_agree() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 登录日志列表:形状是 PageListVO,`creatorTime` 是毫秒数。
let (_, listed) = call(port, "GET", "/api/system/Log?category=1", &token, None).await;
assert_eq!(listed["code"], 200, "登录日志列表失败: {listed}");
let pagination = listed["data"]["pagination"]
.as_object()
.unwrap_or_else(|| panic!("data 必须是 PageListVO: {listed}"));
assert!(pagination.contains_key("total"), "必须有 total: {listed}");
let rows = listed["data"]["list"].as_array().expect("必须有 list");
assert!(!rows.is_empty(), "登录过就必须有登录日志: {listed}");
let row = rows.first().expect("至少一行");
assert_eq!(row["loginMark"], json!(1), "成功登录 ⇒ loginMark=1: {row}");
assert_eq!(row["loginType"], json!(0), "登录 ⇒ loginType=0: {row}");
assert_eq!(row["userName"], json!("管理员"), "用户名取 realName: {row}");
assert_eq!(row["browser"], json!("Chrome"), "UA 应分出 Chrome: {row}");
assert_eq!(row["platForm"], json!("macOS"), "UA 应分出 macOS: {row}");
assert_eq!(row["ipAddress"], json!("127.0.0.1"), "默认回环: {row}");
// 🔴 毫秒时间戳(官方 LoginLogVO.creatorTime 是 Long)—— 13 位量级。
let ts = row["creatorTime"].as_i64().expect("必须是数字");
assert!(ts > 1_600_000_000_000, "必须是毫秒时间戳,实际 {ts}");
// ② 个人中心那条读的是同一张表(同一个用户 ⇒ 同样有行)。
let (_, mine) = call(
port,
"GET",
"/api/permission/Users/Current/SystemLog",
&token,
None,
)
.await;
assert_eq!(mine["code"], 200, "个人中心登录日志失败: {mine}");
let mine_total = mine["data"]["pagination"]["total"].as_i64().unwrap_or(0);
assert!(mine_total >= 1, "个人中心也该看到自己的登录日志: {mine}");
// ③ 访问日志(category=2)官方走 default ⇒ 400,不是空列表。
let (_, denied) = call(port, "GET", "/api/system/Log?category=2", &token, None).await;
assert_eq!(denied["code"], json!(400), "category=2 必须 400: {denied}");
}
/// 三条删除路径的**语义差别**:按 id 删 / 按分类清空 / 只清自己的。
#[tokio::test]
async fn log_delete_paths_have_distinct_semantics() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 先清干净,计数才有确定性。
let (_, cleared) = call(port, "DELETE", "/api/system/Log/1", &token, None).await;
assert_eq!(cleared["code"], 200, "一键清空失败: {cleared}");
let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await;
assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}");
// ① 按 id 批量删。
let _ = login(port).await;
let (_, listed) = call(port, "GET", "/api/system/Log?category=1", &token, None).await;
let id = listed["data"]["list"][0]["id"]
.as_str()
.expect("日志必须有 id")
.to_string();
let body = json!({ "ids": [id] }).to_string();
let (_, deleted) = call(port, "DELETE", "/api/system/Log", &token, Some(&body)).await;
assert_eq!(deleted["code"], 200, "按 id 删除失败: {deleted}");
let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await;
assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}");
// ② 只清自己的(`deleteLoginLog`)—— 自己的删掉就归零。
let _ = login(port).await;
let (_, mine_del) = call(port, "DELETE", "/api/system/Log/deleteLoginLog", &token, None).await;
assert_eq!(mine_del["code"], 200, "清空个人登录日志失败: {mine_del}");
let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await;
assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}");
}
// ---------------------------------------------------------------- 审批常用语
/// 常用语:判重 / 列表 / 下拉 / 使用计数 / 改 / 删。
#[tokio::test]
async fn common_words_crud_and_uses_num() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let text = "同意,请按计划推进";
let body = json!({ "commonWordsText": text, "commonWordsType": 0, "enabledMark": 1 });
let (_, created) = call(
port,
"POST",
"/api/system/CommonWords",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建常用语失败: {created}");
// ① 同文本同类型 ⇒ `SYS105 常用语已存在`。
let (_, dup) = call(
port,
"POST",
"/api/system/CommonWords",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(dup["code"], json!(400), "重复必须 400: {dup}");
assert_eq!(dup["msg"], json!("常用语已存在"), "{dup}");
// ② 列表(公共 type=0)能查到,且形状是 PageListVO。
let (_, listed) = call(
port,
"GET",
"/api/system/CommonWords?commonWordsType=0&currentPage=1&pageSize=20",
&token,
None,
)
.await;
assert_eq!(listed["code"], 200, "常用语列表失败: {listed}");
let row = listed["data"]["list"]
.as_array()
.expect("PageListVO")
.iter()
.find(|x| x["commonWordsText"] == json!(text))
.unwrap_or_else(|| panic!("新建的常用语必须在列表里: {listed}"))
.clone();
let id = row["id"].as_str().expect("必须有 id").to_string();
assert_eq!(row["commonWordsType"], json!(0), "{row}");
// ③ 下拉:`ListVO`(只有 list)。
let (_, selector) = call(
port,
"GET",
"/api/system/CommonWords/Selector?type=0",
&token,
None,
)
.await;
assert_eq!(selector["code"], 200, "常用语下拉失败: {selector}");
assert!(
selector["data"].get("pagination").is_none(),
"Selector 是 ListVO,不该有 pagination: {selector}"
);
// ④ 使用计数:按**文本**加。
let uses = json!({ "commonWordsText": text }).to_string();
let (_, counted) = call(
port,
"POST",
"/api/system/CommonWords/UsesNum",
&token,
Some(&uses),
)
.await;
assert_eq!(counted["code"], 200, "计数失败: {counted}");
let (_, info) = call(port, "GET", &format!("/api/system/CommonWords/{id}"), &token, None).await;
assert_eq!(info["data"]["usesNum"], json!(1), "计数应 +1: {info}");
assert!(info["data"]["systemNames"].is_string(), "详情要补 systemNames: {info}");
// ⑤ 改:只 SET body 出现的键(这里只改文本)。
let patch = json!({ "commonWordsText": "同意,按计划推进(修订)" }).to_string();
let (_, updated) = call(
port,
"PUT",
&format!("/api/system/CommonWords/{id}"),
&token,
Some(&patch),
)
.await;
assert_eq!(updated["code"], 200, "修改失败: {updated}");
let (_, info) = call(port, "GET", &format!("/api/system/CommonWords/{id}"), &token, None).await;
assert_eq!(info["data"]["commonWordsText"], json!("同意,按计划推进(修订)"), "{info}");
assert_eq!(info["data"]["enabledMark"], json!(1), "没给的键不能被清空: {info}");
// ⑥ 删(软删)⇒ 列表里没了。
let (_, deleted) = call(
port,
"DELETE",
&format!("/api/system/CommonWords/{id}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "删除失败: {deleted}");
let (_, listed) = call(
port,
"GET",
"/api/system/CommonWords?commonWordsType=0",
&token,
None,
)
.await;
assert!(
listed["data"]["list"]
.as_array()
.expect("PageListVO")
.iter()
.all(|x| x["id"] != json!(id)),
"软删后不该再出现: {listed}"
);
}
// ---------------------------------------------------------------- 单据规则
/// 单号生成:时间格式 + 位数补零 + **跨天归零**;`f_this_number` 会回写。
#[tokio::test]
async fn bill_number_time_format_and_day_reset() {
let _guard = LOCK.lock().await;
let db = db().await;
let port = serve(new_state(db)).await;
let token = login(port).await;
let ymd = today_ymd(db).await;
let body = json!({
"fullName": "测试单号-时间格式",
"enCode": "biz_test_no",
"category": "9b077e268d4f44e6baa29bb40345f422",
"prefix": "SO",
"type": 1,
"dateFormat": "YYYYMMDD",
"digit": 4,
"startNumber": "1",
});
let (_, created) = call(
port,
"POST",
"/api/system/BillRule",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建单据规则失败: {created}");
// ① 第一次发号:起始值 1 ⇒ `SO{今天}0001`。
let (_, first) = call(
port,
"GET",
"/api/system/BillRule/BillNumber/biz_test_no",
&token,
None,
)
.await;
assert_eq!(first["code"], 200, "发号失败: {first}");
assert_eq!(
first["data"],
json!(format!("SO{ymd}0001")),
"第一次发号应等于 前缀+日期+起始值补零: {first}"
);
// ② 第二次:连续递增(**同一天**不清零)。
let (_, second) = call(
port,
"GET",
"/api/system/BillRule/BillNumber/biz_test_no",
&token,
None,
)
.await;
assert_eq!(second["data"], json!(format!("SO{ymd}0002")), "{second}");
// ③ 跨天归零:把上一号伪造成「去年 1 月 1 日的 0009」⇒ 下次必须回到 0001。
let sql = "UPDATE base_bill_rule SET f_output_number = $1::text, \
f_this_number = $2::text::integer WHERE f_en_code = 'biz_test_no'";
let values = [Some("SO202001010009".to_string()), Some("9".to_string())];
let params: Vec<&(dyn ToSql + Sync)> =
values.iter().map(|v| v as &(dyn ToSql + Sync)).collect();
db.exec_params(sql, &params).await.expect("伪造上一号失败");
let (_, reset) = call(
port,
"GET",
"/api/system/BillRule/BillNumber/biz_test_no",
&token,
None,
)
.await;
assert_eq!(
reset["data"],
json!(format!("SO{ymd}0001")),
"日期段变了就必须从起始值重来: {reset}"
);
// ④ 列表:`category` 要换成字典里的**中文名**(`businessType` 项目管理)。
let (_, listed) = call(port, "GET", "/api/system/BillRule", &token, None).await;
assert_eq!(listed["code"], 200, "单据规则列表失败: {listed}");
let row = listed["data"]["list"]
.as_array()
.expect("PageListVO")
.iter()
.find(|x| x["enCode"] == json!("biz_test_no"))
.unwrap_or_else(|| panic!("新建的规则必须在列表里: {listed}"))
.clone();
assert_eq!(row["category"], json!("项目管理"), "分类要显示中文名: {row}");
assert_eq!(row["creatorUser"], json!("管理员/admin"), "创建人=姓名/账号: {row}");
assert_eq!(row["outputNumber"], json!(format!("SO{ymd}0001")), "{row}");
}
/// 单据规则的几道闸:判重 / 已用不许删 / 导出导入明确不支持 / 改规则清流水。
#[tokio::test]
async fn bill_rule_guards() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = json!({
"fullName": "测试单号-闸门",
"enCode": "biz_guard_no",
"category": "9b077e268d4f44e6baa29bb40345f422",
"prefix": "GD",
"type": 1,
"dateFormat": "YYYYMMDD",
"digit": 3,
"startNumber": "1",
});
let (_, created) = call(
port,
"POST",
"/api/system/BillRule",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建失败: {created}");
// ① 名称重复 ⇒ `EXIST001 名称不能重复`。
let mut dup_name = body.clone();
dup_name["enCode"] = json!("biz_guard_no_2");
let (_, dup) = call(
port,
"POST",
"/api/system/BillRule",
&token,
Some(&dup_name.to_string()),
)
.await;
assert_eq!(dup["code"], json!(400), "{dup}");
assert_eq!(dup["msg"], json!("名称不能重复"), "{dup}");
// ② 编码重复 ⇒ `EXIST002 编码不能重复`。
let mut dup_code = body.clone();
dup_code["fullName"] = json!("测试单号-闸门2");
let (_, dup) = call(
port,
"POST",
"/api/system/BillRule",
&token,
Some(&dup_code.to_string()),
)
.await;
assert_eq!(dup["msg"], json!("编码不能重复"), "{dup}");
// ③ 发一次号 ⇒ 之后不许删(`SYS003`)。
let (_, numbered) = call(
port,
"GET",
"/api/system/BillRule/BillNumber/biz_guard_no",
&token,
None,
)
.await;
assert_eq!(numbered["code"], 200, "{numbered}");
let (_, listed) = call(
port,
"GET",
"/api/system/BillRule?keyword=biz_guard_no",
&token,
None,
)
.await;
let id = listed["data"]["list"][0]["id"]
.as_str()
.expect("必须有 id")
.to_string();
let (_, blocked) = call(
port,
"DELETE",
&format!("/api/system/BillRule/{id}"),
&token,
None,
)
.await;
assert_eq!(blocked["code"], json!(400), "已发号不许删: {blocked}");
assert_eq!(blocked["msg"], json!("单据已经被使用,不允许被删除"), "{blocked}");
// ④ 导出/导入:本仓无文件服务 ⇒ 明确 400(不假装成功)。
let (_, exported) = call(
port,
"GET",
&format!("/api/system/BillRule/{id}/Actions/Export"),
&token,
None,
)
.await;
assert_eq!(exported["code"], json!(400), "{exported}");
let (_, imported) = call(
port,
"POST",
"/api/system/BillRule/Actions/Import",
&token,
Some("{}"),
)
.await;
assert_eq!(imported["code"], json!(400), "{imported}");
// ⑤ 改「位数」= 生成规则变了 ⇒ 流水号状态清空(thisNumber 归 0、outputNumber 归 null)。
let patch = json!({ "digit": 5 }).to_string();
let (_, updated) = call(
port,
"PUT",
&format!("/api/system/BillRule/{id}"),
&token,
Some(&patch),
)
.await;
assert_eq!(updated["code"], 200, "修改失败: {updated}");
let (_, info) = call(
port,
"GET",
&format!("/api/system/BillRule/{id}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["digit"], json!(5), "{info}");
assert_eq!(info["data"]["thisNumber"], json!(0), "改位数应清空流水: {info}");
assert!(info["data"]["outputNumber"].is_null(), "改位数应清空上一号: {info}");
// ⑥ 清空后就能删了。
let (_, deleted) = call(
port,
"DELETE",
&format!("/api/system/BillRule/{id}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "清空流水后应可删: {deleted}");
}
/// 随机数 / UUID 两个分支:位数对得上、两次不同。
#[tokio::test]
async fn bill_number_random_and_uuid() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
for (en_code, kind, extra) in [
("biz_random_no", 2, json!({ "randomDigit": 6, "randomType": 1 })),
("biz_uuid_no", 3, json!({})),
] {
let mut body = json!({
"fullName": format!("测试单号-{en_code}"),
"enCode": en_code,
"category": "9b077e268d4f44e6baa29bb40345f422",
"prefix": "R",
"type": kind,
"dateFormat": "no",
"digit": 1,
"startNumber": "1",
});
if let Some(obj) = extra.as_object() {
for (k, v) in obj {
body[k] = v.clone();
}
}
let (_, created) = call(
port,
"POST",
"/api/system/BillRule",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(created["code"], 200, "新建 {en_code} 失败: {created}");
let path = format!("/api/system/BillRule/BillNumber/{en_code}");
let (_, first) = call(port, "GET", &path, &token, None).await;
let (_, second) = call(port, "GET", &path, &token, None).await;
assert_eq!(first["code"], 200, "{en_code} 发号失败: {first}");
let a = first["data"].as_str().unwrap_or_default().to_string();
let b = second["data"].as_str().unwrap_or_default().to_string();
assert!(a.starts_with('R'), "{en_code} 必须带前缀: {a}");
assert_ne!(a, b, "{en_code} 两次发号不该相同: {a} / {b}");
if kind == 2 {
assert_eq!(a.chars().count(), 1 + 6, "随机数位数应 = prefix 1 + randomDigit 6: {a}");
assert!(
a.chars().skip(1).all(|c| c.is_ascii_digit()),
"randomType=1 ⇒ 数字: {a}"
);
} else {
// UUID 大写、带连字符(官方 `IdUtil.randomUUID().toUpperCase()`)。
assert_eq!(a.chars().count(), 1 + 36, "UUID 应是 36 位(带连字符): {a}");
assert_eq!(a, a.to_uppercase(), "UUID 必须大写: {a}");
}
}
}