feat(msgCenter): 补齐消息中心族 50 条端点并同步契约三处

- 影响:面 B 新增 51 条 `/api/message/**` 端点(契约端点 714 → 765,面 B 684 → 735),官方端点覆盖 700/706 → 751/757,`fe-gap` 的 `msgCenter` 列 49/50 → 50/50。
- 改动:新增 `platform/compat/msg_center.rs` —— 真落库 44 条(账号/发送配置/模板含两张子表/敏感词/接收/监控/供应商,落官方 `base_msg_*` + `base_intg_supplier*` 表),诚实失败 7 条(无 HTTP 客户端 ⇒ 接不了任何消息服务商)。
- 改动:契约生成器新增 msgCenter 族(7 个官方 Controller + 3 条官方前端独有路径),`[ENDPOINT]` +51、`[OFFICIAL]` +51,`[FACE]` 面 B 同步。
- 改动:修 8 处创建人/修改人列(存登录账号不是 UUID)、账号复制列与 CAST 长度错位、子表 `SELECT *` 抄错列、复制账号复制出两个默认账号。
- 改动:新增 `tests/batch20_it.rs`(6 条)—— 逐条打 51 条路径防 matchit 冲突 + CRUD 落库 + 两个 ListVO 形状 + 诚实失败断言 + 未登录 602。
- 设计:官方前端 `testConfig` 声明的是动态路径 ⇒ 加同语义别名 `POST /api/message/Account/{id}` 接住;官方 Java 多暴露、官方前端从不调的 12 条端点本期不做。

Co-Authored-By: Claude Code <[email protected]>
This commit is contained in:
adminandClaude Code committed 2026-11-02 22:29:30 +08:00
1 parent 824a0571e9
commit fc31804f4e
10 files changed
+5924 -19

No files matched your search

+2
View File
@@ -12,6 +12,7 @@
//! | `core` | `api/core/**` | `/api/oauth/*` 等 |
//! | `online_dev` | `api/onlineDev/**` | `/api/onlineDev/*`、`/api/Report/*` |
//! | `work_flow` | `api/workFlow/**` | `/api/workflow/*` |
//! | `msg_center` | `api/msgCenter/**` | `/api/message/*` |
//!
//! 🔴 **`helper` 不是官方模块**:它是契约面的**公共底座**(导入 / 通用工具 /
//! 判别头 / 守卫 / 共享常量 / 菜单与用户信息构造),被多个官方模块共用。
@@ -25,3 +26,4 @@ pub mod core;
pub mod online_dev;
pub mod report;
pub mod workflow;
pub mod msg_center;
File diff suppressed because it is too large. Load diff
+132
View File
@@ -1697,6 +1697,138 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
.route("/api/workflow/trigger/task", get(compat::workflow::workflow_trigger_task_list))
.route("/api/workflow/trigger/task", delete(compat::workflow::workflow_trigger_delete))
.route("/api/workflow/trigger/task/Retry/{id}", post(compat::workflow::workflow_trigger_retry))
// 🔴 **消息中心(msgCenter)50 条** —— 官方前端 `src/api/msgCenter/**` 的全部接口。
// 与上面的 `compat::message`(站内信 / 公告)**不是**一族,路径不重叠。
.route("/api/message/Account", get(compat::msg_center::account_list))
.route("/api/message/Account", post(compat::msg_center::account_create))
.route("/api/message/Account/{id}", get(compat::msg_center::account_info))
.route("/api/message/Account/{id}", put(compat::msg_center::account_update))
.route("/api/message/Account/{id}", delete(compat::msg_center::account_delete))
.route(
"/api/message/Account/{id}/Actions/Copy",
post(compat::msg_center::account_copy),
)
.route(
"/api/message/Account/testSendMail",
post(compat::msg_center::account_test_send),
)
// 🔴 官方前端 `testConfig` 声明的是**动态**路径 `${Api.Prefix}/${data.testType}`
// (`api/msgCenter/accountConfig.ts:33`)⇒ 这条别名把「声明的路径」也接住。
// 静态段 `testSendMail` 优先级更高(matchit 静态 > 参数)⇒ 官方前端那条
// 实际打的是静态端点;两条行为一致(都明确业务失败)。
// 🔴 **参数名必须是 `{id}`**:axum/matchit **同一位置不允许两个不同的参数名**
// (`{id}` 已被上面的 Copy 路由占用 ⇒ 注册 `{testType}` 会直接 panic:
// "Insertion failed due to conflict with previously registered route")。
.route(
"/api/message/Account/{id}",
post(compat::msg_center::account_test_send_by_type),
)
.route(
"/api/message/Account/setdefault",
put(compat::msg_center::account_set_default),
)
.route("/api/message/Send", get(compat::msg_center::send_config_list))
.route("/api/message/Send", post(compat::msg_center::send_config_create))
.route("/api/message/Send/{id}", get(compat::msg_center::send_config_info))
.route("/api/message/Send/{id}", put(compat::msg_center::send_config_update))
.route("/api/message/Send/{id}", delete(compat::msg_center::send_config_delete))
.route(
"/api/message/Send/{id}/Actions/Copy",
post(compat::msg_center::send_config_copy),
)
.route(
"/api/message/Send/getTestConfig/{id}",
post(compat::msg_center::send_config_test_config),
)
.route(
"/api/message/Send/testSendConfig",
post(compat::msg_center::send_config_test_send),
)
.route(
"/api/message/Send/getSendConfigList",
get(compat::msg_center::send_config_select_list),
)
.route("/api/message/Template", get(compat::msg_center::msg_template_list))
.route("/api/message/Template", post(compat::msg_center::msg_template_create))
.route("/api/message/Template/{id}", get(compat::msg_center::msg_template_info))
.route("/api/message/Template/{id}", put(compat::msg_center::msg_template_update))
.route(
"/api/message/Template/{id}",
delete(compat::msg_center::msg_template_delete),
)
.route(
"/api/message/Template/{id}/Actions/Copy",
post(compat::msg_center::msg_template_copy),
)
.route(
"/api/message/Template/testSendMail",
post(compat::msg_center::msg_template_test_send),
)
.route("/api/message/Sensitive", get(compat::msg_center::sensitive_list))
.route("/api/message/Sensitive", post(compat::msg_center::sensitive_create))
.route("/api/message/Sensitive/{id}", get(compat::msg_center::sensitive_info))
.route("/api/message/Sensitive/{id}", put(compat::msg_center::sensitive_update))
.route(
"/api/message/Sensitive/{id}",
delete(compat::msg_center::sensitive_delete),
)
.route("/api/message/Receive", get(compat::msg_center::receive_list))
.route("/api/message/Receive", post(compat::msg_center::receive_save))
.route("/api/message/Monitor", get(compat::msg_center::monitor_list))
.route(
"/api/message/Monitor/detail/{id}",
get(compat::msg_center::monitor_detail),
)
.route(
"/api/message/Monitor/batchRemove",
delete(compat::msg_center::monitor_batch_remove),
)
.route("/api/message/Monitor/empty", delete(compat::msg_center::monitor_empty))
.route(
"/api/message/Monitor/{id}/RecordList",
get(compat::msg_center::monitor_record_list),
)
.route("/api/message/Monitor/Info", get(compat::msg_center::monitor_info))
.route(
"/api/message/Monitor/{id}/Retry",
post(compat::msg_center::monitor_retry),
)
.route("/api/message/Supplier", get(compat::msg_center::supplier_list))
.route("/api/message/Supplier", post(compat::msg_center::supplier_create))
.route(
"/api/message/Supplier/Selector",
get(compat::msg_center::supplier_selector),
)
.route("/api/message/Supplier/{id}", get(compat::msg_center::supplier_info))
.route("/api/message/Supplier/{id}", put(compat::msg_center::supplier_update))
.route(
"/api/message/Supplier/{id}",
delete(compat::msg_center::supplier_delete),
)
.route(
"/api/message/Supplier/TemplateList",
get(compat::msg_center::supplier_template_list),
)
.route(
"/api/message/Supplier/{id}/Actions/Copy",
post(compat::msg_center::supplier_copy),
)
.route(
"/api/message/Supplier/SyncTemplate",
post(compat::msg_center::supplier_sync_template),
)
.route(
"/api/message/Supplier/TestConnect",
post(compat::msg_center::supplier_test_connect),
)
.route(
"/api/message/Supplier/{id}/Actions/State",
put(compat::msg_center::supplier_state),
)
.route(
"/api/message/Supplier/{id}/VariableList",
get(compat::msg_center::supplier_variable_list),
)
.merge(crate::bootstrap::pack_router_or_empty());
// 🔴 **仅测试构建**存在的「故意 panic」端点 —— 用来钉住 catch-all 中间件
+899
View File
@@ -0,0 +1,899 @@
//! 批次 20 —— **msgCenter 族 50 条**的集成测试。
//!
//! 🔴 **本批的形状分三类**(与 `platform/compat/msg_center.rs` 的口径一致):
//! ① **本地可自洽的元数据**(账号配置 / 发送配置 / 消息模板 / 敏感词 /
//! 接收配置 / 监控记录 / 供应商)⇒ **真落库**到官方 `base_msg_*` /
//! `base_intg_supplier*` 表(DDL 逐字照官方);
//! ② **要真连服务商**(测试发送 / 重发 / 同步模板 / 测试连接)⇒ **明确业务失败**
//! (本仓**无 HTTP 客户端**)—— **绝不返假发送结果、假模板**;
//! ③ **官方 Java 有、官方前端没有**的 12 条 ⇒ **不实现**(记在 HANDOFF 的已知限制里)。
//!
//! 🔴 **三类断言**:
//! ① **路由存在**(50 条逐条打一遍)—— 防 axum 的 `matchit` 参数名冲突
//! (同位置不能有两个参数名 ⇒ **启动即 panic**,静态闸门看不出来、编译也过);
//! ② **真实现**的**精确形状**(CRUD 闭环 + `PageListVO` / `ListVO` 的区别);
//! ③ **能力缺失**端点的**诚实失败**(`code=400` + `data:null` + 人话)。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
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 失败");
ssw_platform::bootstrap::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
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(ssw_platform::platform::config::Config::from_env(PathBuf::from(
"/tmp/ssw-platform-batch20-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 面 B 请求(`Vue-Version: 3` + `App-Code: mainSystem`)。
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 v: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
v["data"]["token"]
.as_str()
.expect("登录必须返 token")
.to_string()
}
async fn boot() -> (u16, String) {
let state = new_state(db().await);
let port = serve(state).await;
let token = login(port).await;
(port, token)
}
/// 从 `PageListVO` / `ListVO` 里按 `enCode` 找一条。
fn find_by_en_code(list: &Value, en_code: &str) -> Option<Value> {
list["list"]
.as_array()?
.iter()
.find(|r| r["enCode"].as_str() == Some(en_code))
.cloned()
}
/// 🔴 **50 条端点逐条打一遍** —— 判据「不是 404 / 405」。
///
/// 🔴 **为什么必须有这条测试**:axum 的 `matchit` 在**同一位置有两个参数名**
/// (如 `/api/message/Account/{id}` 与 `/api/message/Account/{accountId}`)时会
/// **启动即 panic** —— 静态闸门看不出来、编译也过,只有真把 router 建起来才炸。
#[tokio::test]
async fn msg_center_all_50_endpoints_are_registered_without_matchit_conflict() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let cases: Vec<(&str, &str)> = vec![
// ---- 账号配置(8 条)----
("GET", "/api/message/Account"),
("POST", "/api/message/Account"),
("GET", "/api/message/Account/{id}"),
("PUT", "/api/message/Account/{id}"),
("DELETE", "/api/message/Account/{id}"),
("POST", "/api/message/Account/{id}/Actions/Copy"),
("POST", "/api/message/Account/testSendMail"),
("PUT", "/api/message/Account/setdefault"),
// ---- 消息发送配置(9 条)----
("GET", "/api/message/Send"),
("POST", "/api/message/Send"),
("GET", "/api/message/Send/{id}"),
("PUT", "/api/message/Send/{id}"),
("DELETE", "/api/message/Send/{id}"),
("POST", "/api/message/Send/{id}/Actions/Copy"),
("POST", "/api/message/Send/getTestConfig/{id}"),
("POST", "/api/message/Send/testSendConfig"),
("GET", "/api/message/Send/getSendConfigList"),
// ---- 消息模板(7 条)----
("GET", "/api/message/Template"),
("POST", "/api/message/Template"),
("GET", "/api/message/Template/{id}"),
("PUT", "/api/message/Template/{id}"),
("DELETE", "/api/message/Template/{id}"),
("POST", "/api/message/Template/{id}/Actions/Copy"),
("POST", "/api/message/Template/testSendMail"),
// ---- 消息安全(5 条)----
("GET", "/api/message/Sensitive"),
("POST", "/api/message/Sensitive"),
("GET", "/api/message/Sensitive/{id}"),
("PUT", "/api/message/Sensitive/{id}"),
("DELETE", "/api/message/Sensitive/{id}"),
// ---- 消息接收(2 条)----
("GET", "/api/message/Receive"),
("POST", "/api/message/Receive"),
// ---- 消息监控(7 条)----
("GET", "/api/message/Monitor"),
("GET", "/api/message/Monitor/Info"),
("DELETE", "/api/message/Monitor/batchRemove"),
("DELETE", "/api/message/Monitor/empty"),
("GET", "/api/message/Monitor/detail/{id}"),
("GET", "/api/message/Monitor/{id}/RecordList"),
("POST", "/api/message/Monitor/{id}/Retry"),
// ---- 消息供应商(12 条)----
("GET", "/api/message/Supplier"),
("POST", "/api/message/Supplier"),
("GET", "/api/message/Supplier/Selector"),
("GET", "/api/message/Supplier/{id}"),
("PUT", "/api/message/Supplier/{id}"),
("DELETE", "/api/message/Supplier/{id}"),
("GET", "/api/message/Supplier/TemplateList"),
("POST", "/api/message/Supplier/{id}/Actions/Copy"),
("POST", "/api/message/Supplier/SyncTemplate"),
("POST", "/api/message/Supplier/TestConnect"),
("PUT", "/api/message/Supplier/{id}/Actions/State"),
("GET", "/api/message/Supplier/{id}/VariableList"),
];
assert_eq!(cases.len(), 50, "本批就是 50 条");
let probe = "b20_probe_no_such_id";
for (method, raw_path) in cases {
let path = raw_path.replace("{id}", probe);
let res = call(port, method, &path, &token, Some("{}")).await;
let code = res["code"].as_i64().unwrap_or(-1);
assert!(
code != 404 && code != 405,
"`{method} {raw_path}` 必须已注册(404/405 说明路由没接上),实际 code={code}:{:?}",
res
);
}
// 🔴 官方前端 `testConfig` 声明的**动态**路径别名(`${Api.Prefix}/${data.testType}`)
// 也必须已注册(官方前端那条静态路径被静态段优先 ⇒ 别名只在别的段名上生效)。
let alias = call(
port,
"POST",
"/api/message/Account/probe-test-type",
&token,
Some("{}"),
)
.await;
let alias_code = alias["code"].as_i64().unwrap_or(-1);
assert!(
alias_code != 404 && alias_code != 405,
"动态路径别名必须已注册,实际 code={alias_code}:{alias:?}"
);
}
/// 🔴 **账号配置 CRUD 闭环**(真落库 `base_msg_account`)。
///
/// 断言官方 `AccountConfigListVO`(17 字段)的形状要点:
/// - `GET /api/message/Account` ⇒ `data` 是 **PageListVO**(`{pagination,list}`);
/// - `category` 是**中文名**(官方 `MessageEnum.getByCode(category).getCategoryName()`),
/// `SMTP` 例外(官方原样保留);
/// - `enabledMark` 是**字符串**(官方 VO 里就是 `String`)。
#[tokio::test]
async fn account_crud_round_trip_matches_official_list_vo() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 新建 ----
let created = call(
port,
"POST",
"/api/message/Account",
&token,
Some(
&json!({
"fullName": "批次20短信账号",
"category": "TencentCloud",
"enCode": "b20_acc_probe",
"messageType": "3",
"addressName": "探针发件人",
"smtpServer": "smtp.example.com",
"smtpPort": 465,
"smtpUser": "[email protected]",
"smtpPassword": "probe-secret",
"enabledMark": 1
})
.to_string(),
),
)
.await;
assert_eq!(created["code"], 200, "新建账号配置必须成功:{created:?}");
assert_eq!(created["msg"], "新建成功", "官方文案:{created:?}");
assert!(created["data"].is_null(), "官方写端点不返数据:{created:?}");
// ---- 列表(PageListVO)----
let listed = call(
port,
"GET",
"/api/message/Account?keyword=b20_acc_probe",
&token,
None,
)
.await;
assert_eq!(listed["code"], 200, "{listed:?}");
assert!(
listed["data"]["pagination"]["currentPage"].as_i64() == Some(1),
"必须是 PageListVO(带 pagination):{listed:?}"
);
assert!(
listed["data"]["pagination"]["total"].as_i64().unwrap_or(0) >= 1,
"列表必须有数据:{listed:?}"
);
let row = find_by_en_code(&listed["data"], "b20_acc_probe").expect("列表里必须有刚建的账号");
let id = row["id"].as_str().expect("id 必须是字符串").to_string();
// 🔴 官方:`category` 走 `MessageEnum.getByCode(...).getCategoryName()` ⇒ 中文名。
assert_eq!(row["category"], "腾讯云", "category 必须是官方中文名:{row:?}");
// 🔴 官方 VO 里 `enabledMark` 是 `String`。
assert!(
row["enabledMark"].is_string(),
"enabledMark 必须是字符串(官方 VO 是 String):{row:?}"
);
// 🔴 官方 VO 里 `type` / `supplierName` / `webhookType` 三个字段**没有来源** ⇒ null。
assert!(row["type"].is_null(), "type 应为 null:{row:?}");
assert!(row["supplierName"].is_null(), "supplierName 应为 null:{row:?}");
assert!(row["webhookType"].is_null(), "webhookType 应为 null:{row:?}");
// 🔴 17 个字段一个不少。
for key in [
"id",
"fullName",
"category",
"type",
"enCode",
"addressorName",
"smtpUser",
"supplierName",
"smsSignature",
"webhookType",
"sortCode",
"enabledMark",
"creatorTime",
"creatorUserId",
"lastModifyTime",
"creatorUser",
"isDefault",
] {
assert!(row.get(key).is_some(), "官方 AccountConfigListVO 少了字段 `{key}`:{row:?}");
}
// ---- 详情 ----
let info = call(port, "GET", &format!("/api/message/Account/{id}"), &token, None).await;
assert_eq!(info["code"], 200, "{info:?}");
assert_eq!(info["data"]["enCode"], "b20_acc_probe", "{info:?}");
assert_eq!(info["data"]["smtpServer"], "smtp.example.com", "{info:?}");
assert_eq!(info["data"]["smtpUser"], "[email protected]", "{info:?}");
assert!(info["data"]["isEditor"].is_boolean(), "官方有 isEditor:{info:?}");
// ---- 更新 ----
let updated = call(
port,
"PUT",
&format!("/api/message/Account/{id}"),
&token,
Some(&json!({"fullName": "批次20短信账号改"}).to_string()),
)
.await;
assert_eq!(updated["code"], 200, "{updated:?}");
assert_eq!(updated["msg"], "更新成功", "{updated:?}");
let info2 = call(port, "GET", &format!("/api/message/Account/{id}"), &token, None).await;
assert_eq!(info2["data"]["fullName"], "批次20短信账号改", "{info2:?}");
// ---- 复制(官方:`.副本` + 5 位、复制件禁用)----
let copied = call(
port,
"POST",
&format!("/api/message/Account/{id}/Actions/Copy"),
&token,
None,
)
.await;
assert_eq!(copied["code"], 200, "{copied:?}");
assert_eq!(copied["msg"], "复制成功", "{copied:?}");
let listed2 = call(port, "GET", "/api/message/Account", &token, None).await;
let copy_row = listed2["data"]["list"]
.as_array()
.expect("list 必须是数组")
.iter()
.find(|r| {
r["enCode"]
.as_str()
.map(|c| c.starts_with("b20_acc_probe") && c != "b20_acc_probe")
.unwrap_or(false)
})
.cloned()
.expect("列表里必须有复制件");
let copy_id = copy_row["id"].as_str().expect("id").to_string();
assert_eq!(
copy_row["enabledMark"], "0",
"官方复制件一律禁用:{copy_row:?}"
);
// ---- 设为默认(官方:一类型一默认;禁用件不许设默认)----
let set_default = call(
port,
"PUT",
"/api/message/Account/setdefault",
&token,
Some(&json!({"id": id}).to_string()),
)
.await;
assert_eq!(set_default["code"], 200, "{set_default:?}");
assert_eq!(set_default["msg"], "操作成功", "{set_default:?}");
let listed3 = call(port, "GET", "/api/message/Account", &token, None).await;
let row3 = find_by_en_code(&listed3["data"], "b20_acc_probe").expect("列表里必须有原账号");
assert_eq!(row3["isDefault"], 1, "设默认后 isDefault 应为 1:{row3:?}");
// 🔴 官方 `FA062`:默认数据不许删。
let del_default = call(port, "DELETE", &format!("/api/message/Account/{id}"), &token, None).await;
assert_eq!(del_default["code"], 400, "默认账号不许删:{del_default:?}");
assert_eq!(del_default["msg"], "默认数据无法删除", "{del_default:?}");
// ---- 删除(复制件)----
let deleted = call(
port,
"DELETE",
&format!("/api/message/Account/{copy_id}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "{deleted:?}");
assert_eq!(deleted["msg"], "删除成功", "{deleted:?}");
let listed4 = call(port, "GET", "/api/message/Account", &token, None).await;
assert!(
find_by_en_code(&listed4["data"], "b20_acc_probe").is_some(),
"原账号还在:{listed4:?}"
);
assert!(
listed4["data"]["list"]
.as_array()
.unwrap()
.iter()
.all(|r| r["id"] != copy_id.as_str()),
"复制件应已软删:{listed4:?}"
);
}
/// 🔴 **消息模板 / 发送配置 CRUD 闭环**(真落库 `base_msg_template` / `base_msg_send`)。
#[tokio::test]
async fn template_and_send_config_crud_round_trip() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 消息模板 ----
let tpl = call(
port,
"POST",
"/api/message/Template",
&token,
Some(
&json!({
"fullName": "批次20模板",
"enCode": "b20_tpl_probe",
"templateType": 1,
"messageType": "3",
"content": "你好 ${name}",
"enabledMark": 1,
"templateParamList": [{"field": "name", "fieldName": "姓名"}],
"msgVariableEntityList": [
{"fieldId": "f1", "variable": "name", "field": "name", "isTitle": 0}
]
})
.to_string(),
),
)
.await;
assert_eq!(tpl["code"], 200, "新建模板必须成功:{tpl:?}");
assert_eq!(tpl["msg"], "新建成功", "{tpl:?}");
let tpls = call(port, "GET", "/api/message/Template", &token, None).await;
assert_eq!(tpls["code"], 200, "{tpls:?}");
assert!(
tpls["data"]["pagination"]["total"].as_i64().unwrap_or(0) >= 1,
"模板列表必须是 PageListVO:{tpls:?}"
);
let tpl_row = find_by_en_code(&tpls["data"], "b20_tpl_probe").expect("列表里必须有刚建的模板");
let tpl_id = tpl_row["id"].as_str().expect("id").to_string();
// 🔴 官方 VO:`messageType` 是**中文名**(`MessageTypeEnum.getByMessage`)。
assert_eq!(tpl_row["messageType"], "短信", "{tpl_row:?}");
// 🔴 子表(参数 / 变量)随模板一起落库。
assert_eq!(
tpl_row["templateParamList"].as_array().map(|a| a.len()),
Some(1),
"模板参数子表必须落库:{tpl_row:?}"
);
assert_eq!(
tpl_row["smsFieldList"].as_array().map(|a| a.len()),
Some(1),
"模板变量子表必须落库:{tpl_row:?}"
);
let tpl_info = call(
port,
"GET",
&format!("/api/message/Template/{tpl_id}"),
&token,
None,
)
.await;
assert_eq!(tpl_info["code"], 200, "{tpl_info:?}");
assert_eq!(tpl_info["data"]["enCode"], "b20_tpl_probe", "{tpl_info:?}");
// ---- 复制模板(官方:连子表一起复制)----
let tpl_copy = call(
port,
"POST",
&format!("/api/message/Template/{tpl_id}/Actions/Copy"),
&token,
None,
)
.await;
assert_eq!(tpl_copy["code"], 200, "{tpl_copy:?}");
assert_eq!(tpl_copy["msg"], "复制成功", "{tpl_copy:?}");
let tpls2 = call(port, "GET", "/api/message/Template", &token, None).await;
let copy_row = tpls2["data"]["list"]
.as_array()
.expect("list 必须是数组")
.iter()
.find(|r| {
r["enCode"]
.as_str()
.map(|c| c.starts_with("b20_tpl_probe") && c != "b20_tpl_probe")
.unwrap_or(false)
})
.cloned()
.expect("列表里必须有模板副本");
let copy_id = copy_row["id"].as_str().expect("id").to_string();
// 🔴 官方复制件:`enabledMark=0`、`templateType="0"`。
assert_eq!(copy_row["enabledMark"], 0, "模板副本必须禁用:{copy_row:?}");
// 🔴 子表也要跟着复制(两张子表列不同 ⇒ 这条钉住「别用同一套列」)。
assert_eq!(
copy_row["templateParamList"].as_array().map(|a| a.len()),
Some(1),
"模板副本必须带上参数子表:{copy_row:?}"
);
assert_eq!(
copy_row["smsFieldList"].as_array().map(|a| a.len()),
Some(1),
"模板副本必须带上变量子表:{copy_row:?}"
);
let tpl_del = call(
port,
"DELETE",
&format!("/api/message/Template/{copy_id}"),
&token,
None,
)
.await;
assert_eq!(tpl_del["code"], 200, "{tpl_del:?}");
assert_eq!(tpl_del["msg"], "删除成功", "{tpl_del:?}");
// ---- 消息发送配置 ----
let send = call(
port,
"POST",
"/api/message/Send",
&token,
Some(
&json!({
"fullName": "批次20发送配置",
"enCode": "b20_send_probe",
"templateType": 1,
"sendType": 1,
"enabledMark": 1
})
.to_string(),
),
)
.await;
assert_eq!(send["code"], 200, "新建发送配置必须成功:{send:?}");
let sends = call(port, "GET", "/api/message/Send", &token, None).await;
assert_eq!(sends["code"], 200, "{sends:?}");
let send_row = find_by_en_code(&sends["data"], "b20_send_probe").expect("列表里必须有刚建的发送配置");
let send_id = send_row["id"].as_str().expect("id").to_string();
// 🔴 官方 VO:`enabledMark` 是字符串。
assert!(send_row["enabledMark"].is_string(), "{send_row:?}");
let send_sel = call(
port,
"GET",
"/api/message/Send/getSendConfigList?keyword=b20_send_probe",
&token,
None,
)
.await;
assert_eq!(send_sel["code"], 200, "{send_sel:?}");
let send_del = call(
port,
"DELETE",
&format!("/api/message/Send/{send_id}"),
&token,
None,
)
.await;
assert_eq!(send_del["code"], 200, "{send_del:?}");
}
/// 🔴 **敏感词 / 接收配置 / 供应商 CRUD 闭环** —— 重点是 **`ListVO` vs `PageListVO`**。
///
/// 🔴 官方口径:
/// - `GET /api/message/Receive` ⇒ **`ListVO`**(只有 `list`,**没有** `pagination`)——
/// 官方 `MsgReceiveController.java:29`;
/// - `GET /api/message/Supplier` ⇒ **`ListVO`**(官方 `IntgSupplierController.java:86`)。
#[tokio::test]
async fn sensitive_receive_supplier_round_trip_and_list_vo_shapes() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// ---- 敏感词 ----
let sens = call(
port,
"POST",
"/api/message/Sensitive",
&token,
Some(
&json!({
"sensitiveWord": "批次20敏感词",
"replaceText": "***",
"enabledMark": 1
})
.to_string(),
),
)
.await;
assert_eq!(sens["code"], 200, "新建敏感词必须成功:{sens:?}");
let sens_list = call(port, "GET", "/api/message/Sensitive", &token, None).await;
assert_eq!(sens_list["code"], 200, "{sens_list:?}");
assert!(
sens_list["data"]["pagination"]["total"].as_i64().unwrap_or(0) >= 1,
"敏感词列表是 PageListVO:{sens_list:?}"
);
let sens_row = sens_list["data"]["list"]
.as_array()
.unwrap()
.iter()
.find(|r| r["sensitiveWord"] == "批次20敏感词")
.cloned()
.expect("列表里必须有刚建的敏感词");
let sens_id = sens_row["id"].as_str().expect("id").to_string();
let sens_upd = call(
port,
"PUT",
&format!("/api/message/Sensitive/{sens_id}"),
&token,
Some(&json!({"replaceText": "###"}).to_string()),
)
.await;
assert_eq!(sens_upd["code"], 200, "{sens_upd:?}");
let sens_del = call(
port,
"DELETE",
&format!("/api/message/Sensitive/{sens_id}"),
&token,
None,
)
.await;
assert_eq!(sens_del["code"], 200, "{sens_del:?}");
assert_eq!(sens_del["msg"], "删除成功", "{sens_del:?}");
// ---- 接收配置(ListVO!)----
let recv = call(port, "GET", "/api/message/Receive", &token, None).await;
assert_eq!(recv["code"], 200, "{recv:?}");
assert!(
recv["data"]["list"].is_array(),
"官方 Receive 返回 ListVO(只有 list):{recv:?}"
);
assert!(
recv["data"]["pagination"].is_null(),
"官方 Receive **不是** PageListVO(不得有 pagination):{recv:?}"
);
let recv_save = call(
port,
"POST",
"/api/message/Receive",
&token,
Some(
&json!({
"type": 1,
"receiveList": [
{
"category": "2046494646179336192",
"enabledMark": 1,
"channels": [{"name": "system", "value": "system"}]
}
]
})
.to_string(),
),
)
.await;
assert_eq!(recv_save["code"], 200, "{recv_save:?}");
let recv2 = call(port, "GET", "/api/message/Receive", &token, None).await;
assert_eq!(recv2["code"], 200, "{recv2:?}");
assert!(
recv2["data"]["list"].as_array().unwrap().len() >= 1,
"保存后接收配置列表必须有数据:{recv2:?}"
);
assert!(
recv2["data"]["pagination"].is_null(),
"官方 Receive 返回 ListVO(不得有 pagination):{recv2:?}"
);
// ---- 供应商(ListVO!)----
let sup = call(
port,
"POST",
"/api/message/Supplier",
&token,
Some(
&json!({
"fullName": "批次20供应商",
"enCode": "b20_sup_probe",
"category": "TencentCloud",
"secretId": "AKIDprobe",
"secretKey": "probe-secret-key",
"enabledMark": 1
})
.to_string(),
),
)
.await;
assert_eq!(sup["code"], 200, "新建供应商必须成功:{sup:?}");
assert_eq!(sup["msg"], "新建成功", "{sup:?}");
let sup_list = call(port, "GET", "/api/message/Supplier", &token, None).await;
assert_eq!(sup_list["code"], 200, "{sup_list:?}");
assert!(
sup_list["data"]["list"].is_array(),
"官方 Supplier 返回 ListVO:{sup_list:?}"
);
assert!(
sup_list["data"]["pagination"].is_null(),
"官方 Supplier **不是** PageListVO(不得有 pagination):{sup_list:?}"
);
let sup_row = find_by_en_code(&sup_list["data"], "b20_sup_probe").expect("列表里必须有刚建的供应商");
let sup_id = sup_row["id"].as_str().expect("id").to_string();
// 🔴 官方 `IntgSupplierListVo` 里没有来源的字段 ⇒ null。
assert!(sup_row["supplierId"].is_null(), "{sup_row:?}");
assert!(sup_row["smsSignature"].is_null(), "{sup_row:?}");
assert!(sup_row["isDefault"].is_null(), "{sup_row:?}");
assert!(sup_row["content"].is_null(), "{sup_row:?}");
// ---- 供应商详情 / 更新 ----
let sup_info = call(
port,
"GET",
&format!("/api/message/Supplier/{sup_id}"),
&token,
None,
)
.await;
assert_eq!(sup_info["code"], 200, "{sup_info:?}");
assert_eq!(sup_info["data"]["enCode"], "b20_sup_probe", "{sup_info:?}");
let sup_upd = call(
port,
"PUT",
&format!("/api/message/Supplier/{sup_id}"),
&token,
Some(
&json!({
"fullName": "批次20供应商改",
"enCode": "b20_sup_probe",
"category": "TencentCloud",
"secretId": "AKIDprobe",
"secretKey": "probe-secret-key"
})
.to_string(),
),
)
.await;
assert_eq!(sup_upd["code"], 200, "{sup_upd:?}");
assert_eq!(sup_upd["msg"], "更新成功", "{sup_upd:?}");
// ---- 启停切换(官方:请求体带**当前**状态,服务端取反)----
let st = call(
port,
"PUT",
&format!("/api/message/Supplier/{sup_id}/Actions/State"),
&token,
Some(&json!({"enabledMark": 1}).to_string()),
)
.await;
assert_eq!(st["code"], 200, "{st:?}");
assert_eq!(st["msg"], "操作成功", "{st:?}");
let sup_list2 = call(port, "GET", "/api/message/Supplier", &token, None).await;
let sup_row2 = find_by_en_code(&sup_list2["data"], "b20_sup_probe").expect("供应商还在");
assert_eq!(
sup_row2["enabledMark"], 0,
"当前是启用 ⇒ 本次操作是禁用:{sup_row2:?}"
);
// ---- 复制 ----
let sup_copy = call(
port,
"POST",
&format!("/api/message/Supplier/{sup_id}/Actions/Copy"),
&token,
None,
)
.await;
assert_eq!(sup_copy["code"], 200, "{sup_copy:?}");
assert_eq!(sup_copy["msg"], "复制成功", "{sup_copy:?}");
// ---- 删除 ----
let sup_del = call(
port,
"DELETE",
&format!("/api/message/Supplier/{sup_id}"),
&token,
None,
)
.await;
assert_eq!(sup_del["code"], 200, "{sup_del:?}");
assert_eq!(sup_del["msg"], "删除成功", "{sup_del:?}");
}
/// 🔴 **能力缺失 ⇒ 明确业务失败**(不返假发送结果 / 假模板)。
///
/// 本仓**没有 HTTP 客户端** ⇒ 真连服务商的动作一律 `code=400` + `data:null` + 人话。
#[tokio::test]
async fn provider_dependent_endpoints_fail_honestly() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let cases: Vec<(&str, &str)> = vec![
("POST", "/api/message/Account/testSendMail"),
// 🔴 前端 `testConfig` 的**动态**路径别名(`${Api.Prefix}/${data.testType}`):
// 这里用一个**非 `testSendMail`** 的段 ⇒ 命中的就是那条动态别名路由
// (静态段优先级更高 ⇒ `testSendMail` 那条走的是官方静态端点)。
("POST", "/api/message/Account/probe-test-type"),
("POST", "/api/message/Send/testSendConfig"),
("POST", "/api/message/Template/testSendMail"),
("POST", "/api/message/Monitor/probe-monitor/Retry"),
("POST", "/api/message/Supplier/SyncTemplate"),
("POST", "/api/message/Supplier/TestConnect"),
];
for (method, path) in cases {
let res = call(port, method, path, &token, Some("{}")).await;
assert_eq!(
res["code"], 400,
"`{method} {path}` 必须明确业务失败(不是 200 假成功):{res:?}"
);
assert!(
res["data"].is_null(),
"`{method} {path}` 失败时 data 必须是 null:{res:?}"
);
let msg = res["msg"].as_str().unwrap_or_default();
assert!(
!msg.is_empty() && msg.contains("消息服务商"),
"`{method} {path}` 的 msg 必须说清「未接入消息服务商」:{res:?}"
);
}
}
/// 🔴 **面 B 未登录 ⇒ `code=602`**(不是 600 —— 官方前端只对 601/602 清 token)。
#[tokio::test]
async fn face_b_unauthenticated_returns_602() {
let _g = LOCK.lock().await;
let (port, _token) = boot().await;
for (method, path) in [
("GET", "/api/message/Account"),
("GET", "/api/message/Sensitive"),
("GET", "/api/message/Receive"),
("GET", "/api/message/Supplier"),
] {
let res = call(port, method, path, "", None).await;
assert_eq!(
res["code"], 602,
"`{method} {path}` 未登录必须是 602:{res:?}"
);
}
}