Files
ssw-platform/src/backend/tests/batch18_it.rs
T
admin 31e0e457ba fix(compat): 修复真实系统性验证发现的 6 处运行时缺陷
- ResetPassword 改读官方 userPassword(已是 md5,原样落库),兼容 password/newPassword;改密后吊销该用户会话
- 修复三处 count SQL 与参数不匹配导致的 code=500;RecordList 同时补 f_monitor_id 过滤(原先会串监控记录)
- updatePasswordMessage 改 200 + data:null(官方前端每页无条件调用且不 catch)
- ensure_schema_all 不再吞掉业务包装载错误
- 路径参数非法时返回信封 400,不再吐纯文本
- 新增 tests/verify_fixes_it.rs 7 条回归;全量 661 passed,verify.sh --smoke 14 步全绿
2026-11-02 23:15:40 +08:00

504 lines
19 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.
//! 批次 18 —— **core 族 22 条**的集成测试。
//!
//! 🔴 core 族(官方 `api/core/{auth,common,user}.ts`)在官方前端**全是「只有声明、
//! 没有消费点」** ⇒ 形状以**官方 Java** 为准(本文件逐条按官方实现断言)。
//!
//! 🔴 三类断言:
//! ① **路由存在**(22 条逐条打一遍)—— 防 axum 的 `matchit` 参数名冲突
//! (同位置不能有两个参数名 ⇒ **启动即 panic**,静态闸门看不出来、编译也过);
//! ② **真实现**的**精确形状**(票据的 `msg`/`data` 错位、扫码状态流转);
//! ③ **能力缺失**端点的**诚实失败**(`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-batch18-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
tickets: Arc::new(TicketStore::default()),
}
}
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)
}
/// 🔴 **22 条端点逐条打一遍** —— 判据「不是 404 / 405」。
///
/// 🔴 **为什么必须有这条测试**:axum 的 `matchit` 在**同一位置有两个参数名**
/// (如 `/api/oauth/getTicketStatus/{ticket}` 与
/// `/api/oauth/getTicketStatus/{id}`)时会**启动即 panic** ——
/// 静态闸门看不出来、编译也过,只有真把 router 建起来才炸。
#[tokio::test]
async fn core_all_22_endpoints_are_registered_without_matchit_conflict() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let lock_body = json!({"account":"admin","password":"x"}).to_string();
let cases: Vec<(&str, &str, Option<&str>)> = vec![
// ---- oauth 族(10 条)----
("POST", "/api/oauth/LockScreen", Some(&lock_body)),
("GET", "/api/oauth/getTicket", None),
("GET", "/api/oauth/getTicketStatus/some-ticket", None),
("GET", "/api/oauth/codeCertificate", None),
("GET", "/api/oauth/codeCertificateStatus/some-ticket", None),
("GET", "/api/oauth/setCodeCertificateStatus/some-ticket/1", None),
("POST", "/api/oauth/updatePasswordMessage", None),
("POST", "/api/oauth/Login/saas", Some("{}")),
("GET", "/api/oauth/mobilecode/saas?mobile=13800000000", None),
("POST", "/api/oauth/apply/saas", Some("{}")),
("POST", "/api/oauth/Login/socials", Some("code=x&source=y")),
// ---- 文件族(4 条)----
("GET", "/api/file/Download/image/a.png", None),
("POST", "/api/file/PackDownload/image", Some("[]")),
("GET", "/api/file/Uploader/Preview", None),
("POST", "/api/file/merge", Some("{}")),
// ---- 导入族(4 条)----
("GET", "/api/system/TemplateDownload", None),
("GET", "/api/permission/ImportPreview", None),
("POST", "/api/permission/ImportData", Some("{}")),
("POST", "/api/onlineDev/ImportExceptionData", Some("{}")),
// ---- 地图族(3 条)----
("GET", "/api/system/Location/around?location=1,1", None),
("GET", "/api/system/Location/text?keywords=x", None),
("GET", "/api/system/Location/inputtips?keywords=x", None),
];
assert_eq!(cases.len(), 22, "本批就是 22 条");
for (method, path, body) in cases {
let res = call(port, method, path, &token, body).await;
let code = res["code"].as_i64().unwrap_or(-1);
assert!(
code != 404 && code != 405,
"`{method} {path}` 必须已注册(404/405 说明路由没接上),实际 code={code}:{:?}",
res
);
}
}
/// 🔴 **`getTicket` 的官方两参信封**:`msg` = 超时毫秒、`data` = 票据。
///
/// 官方 `LoginController.java:383-390`:
/// `return ActionResult.success(ticketModel.getTicketTimeout().toString(), ticket);`
/// 🔴 **官方 `success(msg, data)` 是「先 msg 后 data」** ⇒ 本仓必须照抄这个错位:
/// 有效期进 `msg`、票据进 `data`。
#[tokio::test]
async fn get_ticket_puts_timeout_in_msg_and_ticket_in_data() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/oauth/getTicket", &token, None).await;
assert_eq!(res["code"], 200, "getTicket 应成功:{:?}", res);
// 🔴 `msg` 必须是**毫秒时间戳字符串**(官方 `getTicketTimeout().toString()`)。
let msg = res["msg"].as_str().expect("msg 必须是字符串");
let timeout_ms: i64 = msg
.parse()
.unwrap_or_else(|_| panic!("msg 必须是毫秒时间戳串,实际 {msg:?}"));
assert!(
timeout_ms > 1_600_000_000_000,
"msg 必须是 13 位毫秒时间戳(不是秒!),实际 {msg:?}"
);
// 🔴 `data` 必须是**票据串**。
let ticket = res["data"].as_str().expect("data 必须是票据串");
assert!(!ticket.is_empty(), "data 不能是空串");
// 🔴 拿票据查状态 ⇒ 能查到(官方 `getTicketStatus`)。
let res = call(
port,
"GET",
&format!("/api/oauth/getTicketStatus/{ticket}"),
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "查票据状态应成功:{:?}", res);
// 🔴 官方 `LoginTicketModel` 恰好 4 个字段。
for key in ["status", "value", "theme", "ticketTimeout"] {
assert!(
res["data"].get(key).is_some(),
"官方 `LoginTicketModel` 必须有 `{key}`,实际:{:?}",
res["data"]
);
}
}
/// 🔴 **查一张不存在的票据 ⇒ 官方返 `INVALID` 状态,而不是报错**。
///
/// 官方 `LoginController.java:398-404`:解析不出来 ⇒ 造一张 `status = INVALID`
/// 的空模型**照常返回**(不是 `fail`)。
#[tokio::test]
async fn unknown_ticket_returns_invalid_status_instead_of_error() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(
port,
"GET",
"/api/oauth/getTicketStatus/never-issued-ticket",
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "官方是照常返回,不是失败:{:?}", res);
assert_eq!(
res["data"]["status"], 1,
"查不到票据 ⇒ status 应为 INVALID(1),实际:{:?}",
res["data"]
);
}
/// 🔴 **扫码凭证**:`codeCertificate` 同 `getTicket` 的两参信封;
/// `setCodeCertificateStatus` 能改状态并**续期**。
#[tokio::test]
async fn scan_code_certificate_status_can_be_set_and_read_back() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/oauth/codeCertificate", &token, None).await;
assert_eq!(res["code"], 200, "codeCertificate 应成功:{:?}", res);
let ticket = res["data"].as_str().expect("data 必须是凭证串").to_string();
// 初始状态
let res = call(
port,
"GET",
&format!("/api/oauth/codeCertificateStatus/{ticket}"),
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "查凭证状态应成功:{:?}", res);
let before = res["data"]["ticketTimeout"].as_i64().unwrap_or(0);
assert!(before > 0, "ticketTimeout 必须是毫秒时间戳:{:?}", res["data"]);
// 🔴 官方 `LoginController.java:507-519`:改状态 ⇒ 回吐整张凭证模型。
let res = call(
port,
"GET",
&format!("/api/oauth/setCodeCertificateStatus/{ticket}/2"),
&token,
None,
)
.await;
assert_eq!(res["code"], 200, "设置凭证状态应成功:{:?}", res);
assert_eq!(
res["data"]["status"], 2,
"状态应被改成 2,实际:{:?}",
res["data"]
);
// 再查 ⇒ 状态应保持 2
let res = call(
port,
"GET",
&format!("/api/oauth/codeCertificateStatus/{ticket}"),
&token,
None,
)
.await;
assert_eq!(
res["data"]["status"], 2,
"状态应被持久化,实际:{:?}",
res["data"]
);
}
/// 🔴 **扫码凭证与免密票据不能串用**(官方也是两张不同的 Redis key)。
#[tokio::test]
async fn scan_code_ticket_and_login_ticket_are_not_interchangeable() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/oauth/codeCertificate", &token, None).await;
let scan_ticket = res["data"].as_str().expect("data 必须是凭证串").to_string();
// 🔴 拿**扫码凭证**去查**免密票据**的状态 ⇒ 应查不到(status = INVALID)。
let res = call(
port,
"GET",
&format!("/api/oauth/getTicketStatus/{scan_ticket}"),
&token,
None,
)
.await;
assert_eq!(
res["data"]["status"], 1,
"两种票据不能串用,实际:{:?}",
res["data"]
);
}
/// 🔴 **锁屏解锁**:口令对 ⇒ 成功;口令错 ⇒ 失败。
///
/// 官方 `LoginController.java:130-146`。本仓口令口径 = `md5(明文)`
/// (不是官方的 `md5(明文+secretkey)`)⇒ 前端发密文,本仓解成 `md5(明文)` 再比。
#[tokio::test]
async fn lock_screen_accepts_correct_password_and_rejects_wrong_one() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
// 正确口令
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let res = call(
port,
"POST",
"/api/oauth/LockScreen",
&token,
Some(&json!({ "account": "admin", "password": enc }).to_string()),
)
.await;
assert_eq!(res["code"], 200, "正确口令应解锁成功:{:?}", res);
// 错误口令
let bad = ssw_platform::platform::cipher::encrypt_password("wrong-password");
let res = call(
port,
"POST",
"/api/oauth/LockScreen",
&token,
Some(&json!({ "account": "admin", "password": bad }).to_string()),
)
.await;
assert_eq!(res["code"], 400, "错误口令必须失败:{:?}", res);
assert_eq!(res["data"], Value::Null, "失败时 data 必须是 null");
// 不存在的账号 ⇒ 也失败(且**不区分**「账号不存在」与「口令错」)
let res = call(
port,
"POST",
"/api/oauth/LockScreen",
&token,
Some(&json!({ "account": "no-such-user", "password": enc }).to_string()),
)
.await;
assert_eq!(res["code"], 400, "不存在的账号必须失败:{:?}", res);
}
/// 🔴 **能力缺失的端点必须「诚实失败」**:`code=400` + `data:null` + **有 msg**。
///
/// 🔴 **绝不返假数据**:没有文件存储就不能返一个编出来的下载 URL;
/// 没有地图服务就不能返一组编出来的坐标。
#[tokio::test]
async fn capability_missing_core_endpoints_fail_explicitly() {
let _g = LOCK.lock().await;
let (port, token) = boot().await;
let cases: Vec<(&str, &str, Option<&str>)> = vec![
// 🔴 `updatePasswordMessage` **不在这里**:它虽是「能力缺失」,但官方前端
// `layouts/header/index.vue:74` 每页无条件调用且不 catch ⇒ 只能 200(见 `verify_fixes_it`)。
("POST", "/api/oauth/Login/saas", Some("{}")),
("GET", "/api/oauth/mobilecode/saas?mobile=13800000000", None),
("POST", "/api/oauth/apply/saas", Some("{}")),
("POST", "/api/oauth/Login/socials", Some("code=x")),
("GET", "/api/file/Download/image/a.png", None),
("POST", "/api/file/PackDownload/image", Some("[]")),
("GET", "/api/file/Uploader/Preview", None),
("POST", "/api/file/merge", Some("{}")),
("GET", "/api/system/TemplateDownload", None),
("GET", "/api/permission/ImportPreview", None),
("POST", "/api/permission/ImportData", Some("{}")),
("POST", "/api/onlineDev/ImportExceptionData", Some("{}")),
("GET", "/api/system/Location/around?location=1,1", None),
("GET", "/api/system/Location/text?keywords=x", None),
("GET", "/api/system/Location/inputtips?keywords=x", None),
];
for (method, path, body) in cases {
let res = call(port, method, path, &token, body).await;
assert_eq!(
res["code"], 400,
"`{method} {path}` 能力缺失 ⇒ 必须 code=400(诚实失败),实际:{:?}",
res
);
assert_eq!(
res["data"],
Value::Null,
"`{method} {path}` 失败时 data 必须是 null,实际:{:?}",
res
);
let msg = res["msg"].as_str().unwrap_or("");
assert!(
!msg.trim().is_empty(),
"`{method} {path}` 失败必须带人话 msg,实际:{:?}",
res
);
assert!(
msg.contains("不支持"),
"`{method} {path}` 的 msg 应说明「不支持」并说清缺什么,实际:{msg:?}"
);
}
}
/// 🔴 **`Logout` 未登录也返成功**(官方 `LoginController.java:155` 的 `logout`
/// 是 `@NoDataSourceBind`;前端 `store/auth.ts:86` 把 `logoutApi()` 包在
/// `try { … } catch { /* 忽略 */ }` 里 ⇒ **返回值完全被忽略**,
/// 但 404 会走 `errorMessageResponseInterceptor` 弹红条)。
///
/// 🔴 **实现里 `let _ = require_login_face_b(..)` 是刻意丢弃 `Err`**(不拦)——
/// 这条测试把这个口径钉住:未登录调 Logout ⇒ **200**(不是 602)。
#[tokio::test]
async fn logout_succeeds_without_login_state() {
let _g = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let res = call(port, "POST", "/api/oauth/Logout", "", None).await;
assert_eq!(
res["code"], 200,
"未登录调 `Logout` 也必须成功(官方恒成功),实际:{:?}",
res
);
assert_eq!(res["data"], Value::Null, "Logout 恒返 data=null");
}
/// 🔴 **`Login/saas` 必须真的拦**(官方 `TenantSaasGranter.checkTenantUser`:
/// `UserProvider.getUser().getUserId()` 为空 ⇒ 直接抛 `LoginException(GT105)`)。
///
/// 🔴 **这是本批修掉的一个真偏差**:原先实现写成
/// `let _ = require_login_face_b(..).await;` ⇒ **丢弃了 `Err`** ⇒ 实际不拦,
/// 但静态闸门会把它推成「登录」⇒ **契约标签与运行时行为不符**。
/// ⇒ 现在改成 `if let Err(resp) = .. { return resp; }` ⇒ 未登录返 602。
#[tokio::test]
async fn saas_login_requires_login_state() {
let _g = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
// 未登录 ⇒ 必须被拦(不能落到「不支持」的 400 上)
let res = call(port, "POST", "/api/oauth/Login/saas", "", Some("{}")).await;
assert_eq!(
res["code"], 602,
"未登录调 `Login/saas` 必须返 602(会话失效),实际:{:?}",
res
);
assert_eq!(res["data"], Value::Null, "被拦时 data 必须是 null");
}
/// 🔴 **票据与扫码凭证端点登录前就要用**(官方 `@NoDataSourceBind`)
/// ⇒ 不带 token 也必须能返(不能 600)。
#[tokio::test]
async fn ticket_endpoints_work_without_token() {
let _g = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let res = call(port, "GET", "/api/oauth/getTicket", "", None).await;
assert_eq!(res["code"], 200, "getTicket 不该要 token:{:?}", res);
let res = call(port, "GET", "/api/oauth/codeCertificate", "", None).await;
assert_eq!(res["code"], 200, "codeCertificate 不该要 token:{:?}", res);
}