- bootstrap INSERT 失败时不再回传/打印密钥(否则会打印一个永远登不上的死凭证), 且 main.rs 因「没有身份」直接退出进程 - me_payload_key_set_is_stable 改为走生产函数 me_payload 比对精确键集合(原先是字面量自证) - db_lock 改为进程级单例(pglite-rs 每进程只允许一个 PGlite ⇒ 一个进程只需要一把锁), main.rs 只造一个 AppState - 启动时每次回显生效的身份 id/identityCode;配置码与库中已有身份码不一致时明确告警 - 随机密钥挪到「确定要建身份」之后生成(签发即落库变成结构上的不变量) Co-Authored-By: Claude Code <[email protected]>
315 lines
12 KiB
Rust
315 lines
12 KiB
Rust
//! 身份域端到端:引导 → 登录 → 会话令牌 → Me → Spaces。
|
||
//!
|
||
//! ⚠️ 整个测试二进制共用一个 PGlite 实例(pglite-rs 每进程只允许一个)。
|
||
//! ⚠️ 用例之间用 `SERIAL` 串行化:它们共用同一张 `tdc_identity` 表,
|
||
//! 并发跑会让「谁先建了身份」不确定(引导幂等性断言会随机翻车)。
|
||
|
||
use std::sync::Arc;
|
||
|
||
use axum::extract::State;
|
||
use axum::Router;
|
||
use pglite::PGlite;
|
||
use serde_json::{json, Value};
|
||
use tdc_connector::auth::{auth_middleware, AuthState};
|
||
use tdc_connector::config::Config;
|
||
use tdc_connector::domain::identity;
|
||
use tdc_connector::routes::build_router;
|
||
use tdc_connector::session::SessionStore;
|
||
use tdc_connector::state::{AppState, BootstrapIdentity};
|
||
use tokio::sync::{Mutex, OnceCell};
|
||
|
||
static DB: OnceCell<Arc<PGlite>> = OnceCell::const_new();
|
||
/// 串行闸门:所有碰库的用例排队跑。
|
||
static SERIAL: Mutex<()> = Mutex::const_new(());
|
||
|
||
async fn shared_db() -> Arc<PGlite> {
|
||
DB.get_or_init(|| async {
|
||
let db = Arc::new(PGlite::open_temp().await.expect("打开临时 PGlite 失败"));
|
||
tdc_connector::db::ensure_schema(db.as_ref())
|
||
.await
|
||
.expect("建表失败");
|
||
db
|
||
})
|
||
.await
|
||
.clone()
|
||
}
|
||
|
||
async fn test_state() -> AppState {
|
||
test_state_with(Arc::new(SessionStore::new())).await
|
||
}
|
||
|
||
/// 与 `main.rs` 一致:**登录签发的会话与鉴权中间件必须共用同一个 store**。
|
||
async fn test_state_with(sessions: Arc<SessionStore>) -> AppState {
|
||
let db = shared_db().await;
|
||
let mut config = Config::from_env(std::env::current_dir().unwrap());
|
||
config.identity_code = "TEST-CONNECTOR".to_string();
|
||
config.identity_name = "测试连接器".to_string();
|
||
config.identity_secret = Some("test-secret-key".to_string());
|
||
AppState::new(config, db, sessions, BootstrapIdentity::default())
|
||
}
|
||
|
||
/// 🔴 同一个 PGlite 上的所有 `AppState` 必须共享**同一把** `db_lock`。
|
||
///
|
||
/// pglite-rs 每进程只允许一个 PGlite ⇒ 一个进程只需要一把锁 ⇒ 锁的粒度是**进程**。
|
||
/// (早期实现是「每个 `AppState` 各造一把」⇒ 同一库上两把锁 ⇒ 序列化前提被破坏。)
|
||
#[tokio::test]
|
||
async fn two_app_states_on_the_same_db_share_one_db_lock() {
|
||
let _guard = SERIAL.lock().await;
|
||
let db = shared_db().await;
|
||
let sessions = Arc::new(SessionStore::new());
|
||
let mut config = Config::from_env(std::env::current_dir().unwrap());
|
||
config.identity_code = "TEST-CONNECTOR".to_string();
|
||
|
||
let s1 = AppState::new(
|
||
config.clone(),
|
||
db.clone(),
|
||
sessions.clone(),
|
||
BootstrapIdentity::default(),
|
||
);
|
||
let s2 = AppState::new(
|
||
config.clone(),
|
||
db.clone(),
|
||
sessions.clone(),
|
||
BootstrapIdentity::default(),
|
||
);
|
||
assert!(
|
||
Arc::ptr_eq(&s1.db_lock, &s2.db_lock),
|
||
"同一个 PGlite 上的所有 AppState 必须共享同一把 db_lock"
|
||
);
|
||
// `with_bootstrap` 换引导身份时**不得**换掉锁
|
||
let s3 = s1.with_bootstrap(BootstrapIdentity {
|
||
identity_id: "id-x".to_string(),
|
||
identity_code: "TEST-CONNECTOR".to_string(),
|
||
issued_secret: None,
|
||
});
|
||
assert!(
|
||
Arc::ptr_eq(&s3.db_lock, &s2.db_lock),
|
||
"with_bootstrap 只换 bootstrap 字段,db_lock 必须原样保留"
|
||
);
|
||
assert_eq!(s3.bootstrap.identity_id, "id-x");
|
||
}
|
||
|
||
/// 清空身份表(让「首次引导」用例可确定地拿到「新建」语义)。
|
||
async fn clear_identities(state: &AppState) {
|
||
let _g = state.db_lock.lock().await;
|
||
state
|
||
.db
|
||
.exec("DELETE FROM tdc_identity")
|
||
.await
|
||
.expect("清空 tdc_identity 失败");
|
||
}
|
||
|
||
async fn body_of(resp: axum::response::Response) -> Value {
|
||
let bytes = axum::body::to_bytes(resp.into_body(), usize::MAX)
|
||
.await
|
||
.expect("读取响应体失败");
|
||
serde_json::from_slice(&bytes).expect("响应体不是 JSON")
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn bootstrap_creates_one_identity_and_is_idempotent() {
|
||
let _guard = SERIAL.lock().await;
|
||
let state = test_state().await;
|
||
// 先清空 ⇒ 本用例一定走「首次引导」分支(否则并发下可能被别人抢先建过)。
|
||
clear_identities(&state).await;
|
||
|
||
let first = identity::bootstrap_identity(&state).await;
|
||
assert!(!first.identity_id.is_empty(), "应创建出身份");
|
||
assert_eq!(first.identity_code, "TEST-CONNECTOR");
|
||
assert!(first.issued_secret.is_some(), "首次引导应签发一次密钥");
|
||
|
||
let second = identity::bootstrap_identity(&state).await;
|
||
assert_eq!(second.identity_id, first.identity_id, "引导必须幂等");
|
||
assert!(second.issued_secret.is_none(), "已有身份时不得再签发密钥");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn login_rejects_unknown_identity_and_wrong_secret() {
|
||
let _guard = SERIAL.lock().await;
|
||
let state = test_state().await;
|
||
identity::bootstrap_identity(&state).await;
|
||
|
||
let resp = identity::login(
|
||
State(state.clone()),
|
||
Some(axum::Json(json!({"identityCode": "NOPE", "secretKey": "x"}))),
|
||
)
|
||
.await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["code"], 400);
|
||
assert_eq!(body["msg"], "连接器身份不存在");
|
||
|
||
let resp = identity::login(
|
||
State(state.clone()),
|
||
Some(axum::Json(json!({"identityCode": "TEST-CONNECTOR", "secretKey": "wrong"}))),
|
||
)
|
||
.await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["code"], 400);
|
||
assert_eq!(body["msg"], "连接器身份密钥校验失败");
|
||
|
||
let resp = identity::login(State(state.clone()), Some(axum::Json(json!({"secretKey": "x"}))))
|
||
.await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["msg"], "identityCode 必填");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn login_succeeds_and_me_returns_identity_without_secret() {
|
||
let _guard = SERIAL.lock().await;
|
||
let state = test_state().await;
|
||
identity::bootstrap_identity(&state).await;
|
||
|
||
let resp = identity::login(
|
||
State(state.clone()),
|
||
Some(axum::Json(json!({"identityCode": "TEST-CONNECTOR", "secretKey": "test-secret-key"}))),
|
||
)
|
||
.await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["code"], 200);
|
||
let token = body["data"]["token"].as_str().expect("应返回 token").to_string();
|
||
assert_eq!(body["data"]["identityCode"], "TEST-CONNECTOR");
|
||
|
||
// 会话可查
|
||
let session = state.sessions.lookup(&token).expect("会话应存在");
|
||
assert_eq!(session.identity_code, "TEST-CONNECTOR");
|
||
|
||
// Me 不泄露密钥
|
||
// ⚠️ `me` 有两个参数:`(State, Option<Extension<Principal>>)` ⇒ 第二个参数不能省。
|
||
let resp = identity::me(State(state.clone()), None).await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["code"], 200);
|
||
assert_eq!(body["data"]["identityCode"], "TEST-CONNECTOR");
|
||
assert!(body["data"].get("secretKey").is_none(), "不得回显密钥");
|
||
assert!(body["data"].get("f_secret_key").is_none(), "不得回显密钥列");
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn me_carries_every_field_the_upstream_frontend_reads() {
|
||
let _guard = SERIAL.lock().await;
|
||
let state = test_state().await;
|
||
identity::bootstrap_identity(&state).await;
|
||
|
||
let resp = identity::me(State(state.clone()), None).await;
|
||
let body = body_of(resp).await;
|
||
let data = &body["data"];
|
||
|
||
// 上游前端 `Login.vue` / `IdentityManage.vue` / `ProductManage.vue` 真实读取的字段
|
||
for k in [
|
||
"accessAllowed",
|
||
"reason",
|
||
"account",
|
||
"subjectId",
|
||
"subjectName",
|
||
"tdsSpaceId",
|
||
"tdsSpaceName",
|
||
] {
|
||
assert!(data.get(k).is_some(), "Auth/Me 必须带字段 {}", k);
|
||
}
|
||
// 未登录 ⇒ accessAllowed 必须是 false(前端据此 logout)
|
||
assert_eq!(data["accessAllowed"], json!(false));
|
||
// 单体部署 ⇒ 永不拒 ⇒ reason 恒 null
|
||
assert_eq!(data["reason"], Value::Null);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn spaces_returns_a_bare_array_of_space_views() {
|
||
let _guard = SERIAL.lock().await;
|
||
let state = test_state().await;
|
||
identity::bootstrap_identity(&state).await;
|
||
|
||
let resp = identity::spaces(State(state.clone())).await;
|
||
let body = body_of(resp).await;
|
||
assert_eq!(body["code"], 200);
|
||
// 裸数组(前端 `arr = Array.isArray(list) ? list : (list?.list || [])`)
|
||
assert!(body["data"].is_array(), "Auth/Spaces 的 data 必须是裸数组");
|
||
|
||
// 本地没有平台空间 ⇒ 绑定空间未配时返回空数组(前端 `.catch(() => [])` 容忍)
|
||
let list = body["data"].as_array().unwrap();
|
||
for s in list {
|
||
assert!(s.get("id").is_some(), "空间必须有 id");
|
||
assert!(s.get("name").is_some(), "空间必须有 name");
|
||
assert!(s.get("spaceCode").is_some(), "空间必须有 spaceCode");
|
||
assert_eq!(s.as_object().unwrap().len(), 3, "空间元素恰好三个键");
|
||
}
|
||
}
|
||
|
||
/// 🔴 两套响应形状必须分开:
|
||
/// - 业务失败 = **HTTP 200** + `{code,msg,data}`;
|
||
/// - 鉴权失败 = **HTTP 401** + `{success:false,code,msg}`(**无 `data`**)。
|
||
#[tokio::test]
|
||
async fn business_failure_is_http_200_while_auth_failure_is_http_401() {
|
||
let _guard = SERIAL.lock().await;
|
||
|
||
// 装配带鉴权中间件的真实路由(与 `main.rs` 同一套:会话 store 必须共用)。
|
||
let sessions = Arc::new(SessionStore::new());
|
||
let state = test_state_with(sessions.clone()).await;
|
||
identity::bootstrap_identity(&state).await;
|
||
let auth_state = AuthState {
|
||
internal_token: "test-internal-token".to_string(),
|
||
sessions: sessions.clone(),
|
||
};
|
||
let app: Router = build_router(state.clone())
|
||
.layer(axum::middleware::from_fn_with_state(auth_state, auth_middleware))
|
||
.with_state(state);
|
||
|
||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("绑定端口");
|
||
let addr = listener.local_addr().expect("读本地地址");
|
||
let server = tokio::spawn(async move {
|
||
let _ = axum::serve(listener, app).await;
|
||
});
|
||
// 本机 curl/reqwest 走系统代理会劫持 loopback ⇒ 显式关掉代理。
|
||
let client = reqwest::Client::builder()
|
||
.no_proxy()
|
||
.build()
|
||
.expect("构造 http client");
|
||
let base = format!("http://{}", addr);
|
||
|
||
// ① 鉴权失败:无凭证访问 `Auth/Me` ⇒ HTTP 401 + 裸三字段(无 data)。
|
||
let resp = client.get(format!("{}/api/ssw/tdc/Auth/Me", base)).send().await.expect("请求失败");
|
||
assert_eq!(resp.status().as_u16(), 401, "鉴权失败必须是 HTTP 401");
|
||
let body: Value = resp.json().await.expect("响应体不是 JSON");
|
||
assert_eq!(body["success"], json!(false));
|
||
assert_eq!(body["code"], json!(401));
|
||
assert!(body.get("data").is_none(), "鉴权失败 body 不得含 data:{}", body);
|
||
assert_eq!(body.as_object().unwrap().len(), 3, "鉴权失败 body 恰好三个键");
|
||
|
||
// ② 业务失败:密钥不对 ⇒ HTTP 200 + `{code:400,msg,data}`。
|
||
let resp = client
|
||
.post(format!("{}/api/ssw/tdc/Auth/Login", base))
|
||
.json(&json!({"identityCode": "TEST-CONNECTOR", "secretKey": "wrong"}))
|
||
.send()
|
||
.await
|
||
.expect("请求失败");
|
||
assert_eq!(resp.status().as_u16(), 200, "业务失败必须是 HTTP 200");
|
||
let body: Value = resp.json().await.expect("响应体不是 JSON");
|
||
assert_eq!(body["code"], json!(400));
|
||
assert_eq!(body["msg"], json!("连接器身份密钥校验失败"));
|
||
assert!(body.get("success").is_none(), "业务信封不得含 success 字段");
|
||
assert!(body.get("data").is_some(), "业务信封带 data 键(此处为 null)");
|
||
|
||
// ③ 登录成功 ⇒ 拿到令牌;带令牌再取 `Auth/Spaces` ⇒ 裸数组。
|
||
let resp = client
|
||
.post(format!("{}/api/ssw/tdc/Auth/Login", base))
|
||
.json(&json!({"identityCode": "TEST-CONNECTOR", "secretKey": "test-secret-key"}))
|
||
.send()
|
||
.await
|
||
.expect("请求失败");
|
||
assert_eq!(resp.status().as_u16(), 200);
|
||
let body: Value = resp.json().await.expect("响应体不是 JSON");
|
||
assert_eq!(body["code"], json!(200));
|
||
let token = body["data"]["token"].as_str().expect("应返回 token").to_string();
|
||
|
||
let resp = client
|
||
.get(format!("{}/api/ssw/tdc/Auth/Spaces", base))
|
||
.header("X-Auth-Token", token)
|
||
.send()
|
||
.await
|
||
.expect("请求失败");
|
||
assert_eq!(resp.status().as_u16(), 200);
|
||
let body: Value = resp.json().await.expect("响应体不是 JSON");
|
||
assert_eq!(body["code"], json!(200));
|
||
assert!(body["data"].is_array(), "Auth/Spaces 的 data 必须是裸数组");
|
||
|
||
server.abort();
|
||
}
|