- 内核只有 lib:启动装配 → crates/sspf-admin(bin sspf-admin);37 个集成测试 → crates/tests(package sspf-tests)。
- demo/shop/books 的 spec/菜单/DDL/面 B 路由搬进 packs/{demo,shop,books};内核 modules/*.rs 只剩「面 A 适配器 + pub use」⇒ 内核零业务知识,示例可整目录搬走。面 A 与前端零改动。
- 示例表 DDL 按平台规则补 f_tenant_id + 复合主键(spec 不加 ⇒ JSON 键与响应逐字不变)。
- 修 is_builtin_table 只认 schema.sql 的漏洞:包表(含 asset_data_resource)此前可被建模页删除/改;现为「平台 DDL ∪ 包表」。
- sspf-compat-online_dev → onlinedev(包名/模块/文件/路由别名同步);6 个 5 行转发壳合并为 forward.rs。
- 新增 AR16 闸门 + lib.rs「30 秒地图」+ src/backend/README.md;pack-sync 补两处判据(module_key=None 的 urlAddress、apiFile 查存在性)。
- 回归:704 tests / 6 道静态闸门全绿;health 181 表;四个包面 A/面 B 运行时全部 200。
655 lines
24 KiB
Rust
655 lines
24 KiB
Rust
//! 批次 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 sspf_core::config::Config;
|
||
use sspf_core::db::{pglite::ToSql, Db};
|
||
use sspf_core::seed::first_seed;
|
||
use sspf_core::session::{SessionStore, TicketStore};
|
||
use sspf_core::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 = sspf_core::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¤tPage=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, ¶ms).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}");
|
||
}
|
||
}
|
||
}
|