diff --git a/src/backend/src/auth.rs b/src/backend/src/auth.rs index b027d0f..50a47d5 100644 --- a/src/backend/src/auth.rs +++ b/src/backend/src/auth.rs @@ -1,3 +1,214 @@ -//! auth —— 登录 / CurrentUser / 鉴权守卫。 +//! auth —— 登录(`/api/oauth/Login`)、当前用户(`/api/oauth/CurrentUser`)与两个请求守卫。 //! -//! TODO:占位模块,后续任务填充实现。 +//! 契约:规格 §6.1(认证)+ §9(`auth.rs` 接口)。 +//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/auth/`。 +//! +//! 🔴 **三条硬约定**: +//! 1. **业务失败恒 HTTP 200**:登录失败 `code=400`、未登录 `code=600`、无菜单权限 `code=403` +//! —— 全都是**信封里的 code**,不是 HTTP 状态码(**别抄 `tdc-rs` 的裸 401/403**)。 +//! 2. **表单解析失败也要走业务信封**:axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` +//! ⇒ `Option>` 编译不过 ⇒ 登录端点取**原始 body** 自己解析, +//! 解析失败返回 `fail(400, "缺少 account / password")`,**不是** axum 默认的 400 文本。 +//! 3. **口令不得外泄**:请求体里的密文只在内存里比对,响应体里**永不**回显; +//! 库里存的是 `md5(明文)`(`base_user.f_password`)。 + +use axum::body::Bytes; +use axum::extract::State; +use axum::http::HeaderMap; +use axum::Json; +use serde_json::{json, Value}; + +use crate::cipher::decrypt_to_md5; +use crate::envelope::{fail, ok, ActionResult}; +use crate::permission::{build_menu_list, has_module}; +use crate::session::TokenUser; +use crate::state::AppState; + +/// token 有效期(秒)—— 契约 §6.1:恒为 `7200`。 +const TOKEN_EXPIRES_IN: i64 = 7200; + +/// 登录成功体里的 `tokenTypeName` —— 契约 §6.1:恒为 `"bearer"`。 +const TOKEN_TYPE_NAME: &str = "bearer"; + +/// 登录表单(**form-urlencoded**)。 +/// +/// 🔴 三个字段全是 `Option`:缺字段也要走**业务信封**(`code=400`), +/// 不能落到 axum 默认的 400 文本。 +/// 🔴 `grant_type` 是 **snake_case 字面量**(协议规定),**不能**改成 camelCase。 +#[derive(serde::Deserialize, Debug, Default, Clone)] +pub struct LoginForm { + /// 登录账号。 + pub account: Option, + /// 口令**密文**(hex)。 + pub password: Option, + /// 授权类型(`password`;可缺省)。 + pub grant_type: Option, +} + +/// 登录(契约 §6.1)。 +/// +/// 校验顺序(**不可换**,规格 §6.1 + brief S14): +/// 1. `account` 或 `password` 为空 ⇒ `fail(400, "缺少 account / password")`; +/// 2. `grant_type` 存在且 ≠ `password` ⇒ `fail(400, "不支持的 grant_type")`; +/// 3. 账号不存在 / 已软删 / 口令不等 / **密文非法** ⇒ `fail(400, "账号或密码错误")`。 +/// +/// 🔴 密文非法(`decrypt_to_md5` 返回 `None`)与「口令错」是**同一条消息** +/// (react 的 `decryptToMd5` 失败返空串 ⇒ 比对不等 ⇒ 同一分支)⇒ 不另造文案。 +/// +/// 🔴 口令比对**大小写不敏感**(两边都转小写再比)。 +/// 🔴 查用户**只比未软删的行**(`f_delete_mark = 0`)。 +pub async fn login(state: &AppState, body: LoginForm) -> Json { + let account = body.account.unwrap_or_default(); + let encrypted = body.password.unwrap_or_default(); + + // ---- 序 1:缺 account / password ---- + if account.is_empty() || encrypted.is_empty() { + return fail(400, "缺少 account / password"); + } + + // ---- 序 2:grant_type 不支持 ---- + // 🔴 `grant_type` **缺失是允许的**;空串按「未设置」处理(与 react 的 falsy 判定一致)。 + if let Some(grant_type) = body.grant_type.as_deref() { + if !grant_type.is_empty() && grant_type != "password" { + return fail(400, "不支持的 grant_type"); + } + } + + // ---- 序 3:查用户(只比未软删的)---- + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"password\", \ + f_is_administrator AS \"isAdministrator\" \ + FROM base_user WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", + &[&account], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + // 🔴 DB 报错不能变成裸 HTTP 500(信封里只有业务码)⇒ 走「账号或密码错误」 + // 这条**不泄露信息**的分支,同时把真因打进日志。 + eprintln!("[auth] 查询用户失败(按账号或密码错误处理): {e}"); + return fail(400, "账号或密码错误"); + } + }; + + let Some(row) = rows.first() else { + // 账号不存在(或已软删)。 + return fail(400, "账号或密码错误"); + }; + + // 库内存的是 `md5(明文)`;密文解出来也是 `md5(明文)` ⇒ 直接比。 + // 🔴 `f_password` 可能是 NULL(官方 DDL 允许)⇒ 视为不匹配。 + let stored = row.get("password").and_then(Value::as_str).unwrap_or(""); + let plain_md5 = match decrypt_to_md5(&encrypted) { + Some(md5) => md5, + // 🔴 密文非法(非法 hex / 非法 PKCS7 填充)⇒ **同一条**「账号或密码错误」。 + None => return fail(400, "账号或密码错误"), + }; + if stored.is_empty() || stored.to_lowercase() != plain_md5.to_lowercase() { + return fail(400, "账号或密码错误"); + } + + let user_id = row.get("id").and_then(Value::as_str).unwrap_or("").to_string(); + let account = row + .get("account") + .and_then(Value::as_str) + .unwrap_or(account.as_str()) + .to_string(); + let is_admin = row + .get("isAdministrator") + .and_then(Value::as_i64) + .and_then(|v| i32::try_from(v).ok()) + .unwrap_or(0); + + let token = state.sessions.issue(&account, &user_id, is_admin); + ok(json!({ + "token": token, + "expiresIn": TOKEN_EXPIRES_IN, + "tokenTypeName": TOKEN_TYPE_NAME, + })) +} + +/// 登录端点的**原始 body** 版本(契约 §6.1 的实现注记)。 +/// +/// 🔴 axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` ⇒ `Option>` 编译不过 +/// ⇒ 这里自己用 `serde_urlencoded` 解析。 +/// 🔴 **解析失败也走业务信封**(`fail(400, "缺少 account / password")`), +/// 绝不能让 axum 返默认的 400 文本(前端拿到的是 HTML/纯文本,不是 `{code,msg,data}`)。 +pub async fn login_from_bytes(state: &AppState, body: Bytes) -> Json { + let form = match serde_urlencoded::from_bytes::(&body) { + Ok(form) => form, + Err(_) => return fail(400, "缺少 account / password"), + }; + login(state, form).await +} + +/// axum handler(`POST /api/oauth/Login`)—— Task 10 装配路由时直接用它。 +pub async fn login_handler(State(state): State, body: Bytes) -> Json { + login_from_bytes(&state, body).await +} + +/// 当前用户(契约 §6.1)。 +/// +/// - 未登录 ⇒ `fail(600, "未登录")`; +/// - 成功 ⇒ `data = {"userInfo": {...}, "menuList": [...]}`。 +/// +/// 🔴 `userName` = **账号**(不是 `realName`);`isAdministrator` 是 **JSON 布尔**。 +pub async fn current_user(state: &AppState, headers: HeaderMap) -> Json { + let Some(user) = resolve_user(state, &headers) else { + return fail(600, "未登录"); + }; + + let menu_list = build_menu_list(&state.db, &user.user_id, user.is_admin).await; + + ok(json!({ + "userInfo": { + "userId": user.user_id, + "userAccount": user.account, + "userName": user.account, + "isAdministrator": user.is_admin == 1, + }, + "menuList": menu_list, + })) +} + +/// 守卫:**未登录** ⇒ `Err(fail(600, "未登录"))`;已登录 ⇒ `Ok(TokenUser)`。 +/// +/// 🔴 失败也是 **HTTP 200** + `code=600`(不是 401)。 +pub async fn require_login( + state: &AppState, + headers: &HeaderMap, +) -> Result> { + match resolve_user(state, headers) { + Some(user) => Ok(user), + None => Err(fail(600, "未登录")), + } +} + +/// 守卫:**登录 + 菜单权限**。 +/// +/// 1. 先 `require_login`(未登录 ⇒ `600`); +/// 2. 再 `has_module(...)`;无权限 ⇒ `Err(fail(403, "无菜单权限"))`。 +/// +/// 🔴 失败也是 **HTTP 200** + `code=403`(不是 403 状态码)。 +pub async fn require_module( + state: &AppState, + headers: &HeaderMap, + module_key: &str, +) -> Result> { + let user = require_login(state, headers).await?; + if has_module(&state.db, &user.user_id, user.is_admin, module_key).await { + Ok(user) + } else { + Err(fail(403, "无菜单权限")) + } +} + +/// 从 `Authorization` 头解析出当前用户(无 / 非法 ⇒ `None`)。 +fn resolve_user(state: &AppState, headers: &HeaderMap) -> Option { + let auth = headers.get("authorization")?; + let auth = auth.to_str().ok()?; + state.sessions.resolve(Some(auth)) +} diff --git a/src/backend/tests/auth_it.rs b/src/backend/tests/auth_it.rs new file mode 100644 index 0000000..bb1f66f --- /dev/null +++ b/src/backend/tests/auth_it.rs @@ -0,0 +1,425 @@ +//! auth 集成测试 —— 登录 / 当前用户 / 两个守卫。 +//! +//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 +//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库** +//! (`OnceCell` 起一次),不每个测试函数各开一个。 +//! +//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的 +//! `#[tokio::test]` **并发**跑(不同线程)⇒ 共用一个库时它们会互相踩数据。 +//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。 +//! 🔴 **不依赖测试执行顺序**:每个测试自己造前置条件(自己的 token / 自己的用户)。 + +use std::path::PathBuf; +use std::sync::Arc; + +use axum::body::Bytes; +use axum::http::{HeaderMap, HeaderValue}; +use axum::Json; +use tds_lite_rs::auth::{ + current_user, login, login_from_bytes, require_login, require_module, LoginForm, +}; +use tds_lite_rs::cipher::{encrypt_password, md5_hex}; +use tds_lite_rs::config::Config; +use tds_lite_rs::db::Db; +use tds_lite_rs::envelope::ActionResult; +use tds_lite_rs::ids::new_uuid; +use tds_lite_rs::seed::{ensure_base, first_seed}; +use tds_lite_rs::session::{SessionStore, TokenUser}; +use tds_lite_rs::state::AppState; +use tokio::sync::{Mutex, OnceCell}; + +/// 全文件共享的临时库。 +static DB: OnceCell = OnceCell::const_new(); + +/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 +static LOCK: Mutex<()> = Mutex::const_new(()); + +/// 管理员账号(契约 §8.6 的 `admin`)。 +const ADMIN_ACCOUNT: &str = "admin"; + +/// 管理员口令(契约 §8.6:种子口令 `123456`)。 +const ADMIN_PLAIN: &str = "123456"; + +async fn db() -> &'static Db { + DB.get_or_init(|| async { + let db = Db::open_temp().await.expect("打开 pglite 临时库失败"); + db.ensure_schema().await.expect("ensure_schema 失败"); + ensure_base(&db).await.expect("ensure_base 失败"); + first_seed(&db).await.expect("first_seed 失败"); + db + }) + .await +} + +/// 造一个应用状态(**每个测试自己一份** ⇒ token 表互不干扰)。 +fn new_state(db: &Db) -> AppState { + AppState { + config: Arc::new(Config::from_env(PathBuf::from("/tmp/tds-lite-rs-auth-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::new()), + } +} + +/// 带 `bearer ` 的请求头。 +fn auth_headers(token: &str) -> HeaderMap { + let mut headers = HeaderMap::new(); + let value = + HeaderValue::from_str(&format!("bearer {}", token)).expect("token 必须是合法 header 值"); + headers.insert("authorization", value); + headers +} + +/// 守卫的**失败**分支(`ActionResult` / `TokenUser` 都不实现 `Debug` ⇒ 不用 `expect_err`)。 +fn expect_guard_err(res: Result>, ctx: &str) -> ActionResult { + match res { + Ok(_) => panic!("{ctx}:必须失败,却放行了"), + Err(e) => e.0, + } +} + +/// 守卫的**放行**分支。 +fn expect_guard_ok(res: Result>, ctx: &str) -> TokenUser { + match res { + Ok(user) => user, + Err(e) => panic!( + "{ctx}:必须放行,实际 code={} msg={}", + e.0.code, e.0.msg + ), + } +} + +/// 造一个**非管理员**用户(口令 `123456`),返回它的 id。 +async fn insert_plain_user(db: &Db, account: &str) -> String { + let id = new_uuid(); + let password = md5_hex(ADMIN_PLAIN); + let is_admin = "0".to_string(); + let delete_mark = "0".to_string(); + let params: [&(dyn tds_lite_rs::db::pglite::ToSql + Sync); 5] = [ + &id, + &account.to_string(), + &password, + &is_admin, + &delete_mark, + ]; + db.exec_params( + "INSERT INTO base_user \ + (f_id, f_account, f_password, f_is_administrator, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::integer, '0')", + ¶ms, + ) + .await + .expect("插入测试用户失败"); + id +} + +// ---- 登录 ---- + +/// 空 body ⇒ `code=400`、`msg="缺少 account / password"`。 +/// +/// 🔴 **整个 body 解析失败也走同一条消息**(不是 axum 默认的 400 文本)。 +#[tokio::test] +async fn login_with_empty_body_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let res = login_from_bytes(&state, Bytes::new()).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "缺少 account / password"); + assert_eq!(res.0.data, serde_json::Value::Null); +} + +/// 解析成功但 `account` / `password` 缺一 ⇒ 同样 `400 "缺少 account / password"`。 +#[tokio::test] +async fn login_without_credentials_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + // 只有 account,没有 password。 + let res = login_from_bytes(&state, Bytes::from_static(b"account=admin")).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "缺少 account / password"); + + // 已解析的表单走同一条分支。 + let res = login( + &state, + LoginForm { + account: Some(ADMIN_ACCOUNT.to_string()), + password: None, + grant_type: None, + }, + ) + .await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "缺少 account / password"); +} + +/// `grant_type=foo` ⇒ `code=400`、`msg="不支持的 grant_type"`。 +#[tokio::test] +async fn login_with_unsupported_grant_type_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!( + "account={}&password={}&grant_type=foo", + ADMIN_ACCOUNT, + encrypt_password(ADMIN_PLAIN) + ); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "不支持的 grant_type"); +} + +/// 口令错 ⇒ `code=400`、`msg="账号或密码错误"`。 +#[tokio::test] +async fn login_with_wrong_password_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!( + "account={}&password={}&grant_type=password", + ADMIN_ACCOUNT, + encrypt_password("wrong-password") + ); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "账号或密码错误"); +} + +/// 🔴 密文非法(非法 hex)⇒ **同一条** `400 "账号或密码错误"`(不许另造文案)。 +#[tokio::test] +async fn login_with_invalid_ciphertext_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!("account={}&password=not-hex&grant_type=password", ADMIN_ACCOUNT); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "账号或密码错误"); +} + +/// 账号不存在 ⇒ `code=400`、`msg="账号或密码错误"`。 +#[tokio::test] +async fn login_with_unknown_account_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!( + "account=auth_it_no_such_user&password={}&grant_type=password", + encrypt_password(ADMIN_PLAIN) + ); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 400); + assert_eq!(res.0.msg, "账号或密码错误"); +} + +/// 口令正确 ⇒ `code=200`,`data.token` 非空、`expiresIn==7200`、`tokenTypeName=="bearer"`。 +#[tokio::test] +async fn login_with_correct_password_succeeds() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!( + "account={}&password={}&grant_type=password", + ADMIN_ACCOUNT, + encrypt_password(ADMIN_PLAIN) + ); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 200); + assert_eq!(res.0.msg, "成功"); + + let data = res.0.data.as_object().expect("data 必须是对象"); + let token = data["token"].as_str().expect("token 必须是字符串"); + assert!(!token.is_empty(), "token 不得为空"); + assert_eq!(data["expiresIn"], serde_json::json!(7200)); + assert_eq!(data["tokenTypeName"], serde_json::json!("bearer")); + + // 🔴 口令**不得外泄**:响应里不得出现密文或 md5。 + let serialized = serde_json::to_string(&res.0.data).unwrap(); + assert!( + !serialized.contains(&encrypt_password(ADMIN_PLAIN)), + "响应里不得回显密文" + ); + assert!( + !serialized.contains(&md5_hex(ADMIN_PLAIN)), + "响应里不得回显口令摘要" + ); +} + +/// 🔴 `grant_type` **缺失是允许的**(只有「存在且 ≠ password」才失败)。 +#[tokio::test] +async fn login_without_grant_type_is_allowed() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let body = format!( + "account={}&password={}", + ADMIN_ACCOUNT, + encrypt_password(ADMIN_PLAIN) + ); + let res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(res.0.code, 200, "缺 grant_type 必须放行"); +} + +// ---- CurrentUser ---- + +/// CurrentUser 无 token ⇒ `code=600`、`msg="未登录"`。 +#[tokio::test] +async fn current_user_without_token_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let res = current_user(&state, HeaderMap::new()).await; + assert_eq!(res.0.code, 600); + assert_eq!(res.0.msg, "未登录"); + assert_eq!(res.0.data, serde_json::Value::Null); +} + +/// CurrentUser 有 token ⇒ `code=200`,`userInfo` 形状正确、`menuList` 是 4 个根菜单的数组。 +#[tokio::test] +async fn current_user_with_token_returns_user_info_and_menu() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + // 先登录拿 token。 + let body = format!( + "account={}&password={}&grant_type=password", + ADMIN_ACCOUNT, + encrypt_password(ADMIN_PLAIN) + ); + let login_res = login_from_bytes(&state, Bytes::from(body)).await; + assert_eq!(login_res.0.code, 200); + let token = login_res.0.data["token"] + .as_str() + .expect("token 必须是字符串") + .to_string(); + + let res = current_user(&state, auth_headers(&token)).await; + assert_eq!(res.0.code, 200); + + let data = res.0.data.as_object().expect("data 必须是对象"); + let user_info = data["userInfo"].as_object().expect("userInfo 必须是对象"); + assert_eq!(user_info["userAccount"], serde_json::json!("admin")); + assert_eq!(user_info["userName"], serde_json::json!("admin")); + assert!( + user_info["isAdministrator"].is_boolean(), + "isAdministrator 必须是 JSON 布尔:{:?}", + user_info["isAdministrator"] + ); + assert_eq!(user_info["isAdministrator"], serde_json::json!(true)); + assert!( + user_info["userId"].as_str().is_some_and(|s| !s.is_empty()), + "userId 必须是非空字符串" + ); + + let menu = data["menuList"].as_array().expect("menuList 必须是数组"); + assert_eq!(menu.len(), 4, "管理员应看到 4 个根菜单"); +} + +// ---- 守卫 ---- + +/// `require_login`:无 token ⇒ `code=600`。 +#[tokio::test] +async fn require_login_without_token_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let err = expect_guard_err( + require_login(&state, &HeaderMap::new()).await, + "无 token 的 require_login", + ); + assert_eq!(err.code, 600); + assert_eq!(err.msg, "未登录"); +} + +/// `require_login`:有 token ⇒ `Ok(TokenUser)`(账号 = admin)。 +#[tokio::test] +async fn require_login_with_token_succeeds() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let token = state.sessions.issue(ADMIN_ACCOUNT, "auth_it_uid", 1); + let user = expect_guard_ok( + require_login(&state, &auth_headers(&token)).await, + "有 token 的 require_login", + ); + assert_eq!(user.account, ADMIN_ACCOUNT); + assert_eq!(user.is_admin, 1); +} + +/// `require_module`:无 token ⇒ `code=600`(**先**判登录)。 +#[tokio::test] +async fn require_module_without_token_fails() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let err = expect_guard_err( + require_module(&state, &HeaderMap::new(), "system/User").await, + "无 token 的 require_module", + ); + assert_eq!(err.code, 600); + assert_eq!(err.msg, "未登录"); +} + +/// `require_module`:管理员短路放行(不需要任何授权行)。 +#[tokio::test] +async fn require_module_allows_administrator() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let token = state.sessions.issue(ADMIN_ACCOUNT, "auth_it_admin_uid", 1); + let user = expect_guard_ok( + require_module(&state, &auth_headers(&token), "system/User").await, + "管理员的 require_module", + ); + assert_eq!(user.account, ADMIN_ACCOUNT); +} + +/// `require_module`:非管理员 + 菜单已映射 + 无授权 ⇒ `code=403`。 +#[tokio::test] +async fn require_module_denies_plain_user_without_grant() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let account = "auth_it_plain_user"; + let user_id = insert_plain_user(db, account).await; + let token = state.sessions.issue(account, &user_id, 0); + + let err = expect_guard_err( + require_module(&state, &auth_headers(&token), "system/User").await, + "非管理员无授权的 require_module", + ); + assert_eq!(err.code, 403); + assert_eq!(err.msg, "无菜单权限"); +} + +/// `require_module`:菜单**未映射** ⇒ 放行(对齐 `SswPermissionGuard` 的 warn 路径)。 +#[tokio::test] +async fn require_module_allows_unmapped_module_key() { + let db = db().await; + let _guard = LOCK.lock().await; + let state = new_state(db); + + let account = "auth_it_unmapped_user"; + let user_id = insert_plain_user(db, account).await; + let token = state.sessions.issue(account, &user_id, 0); + + expect_guard_ok( + require_module(&state, &auth_headers(&token), "not/mapped/anywhere").await, + "未映射 key 的 require_module", + ); +}