use super::mock::{MockDao, MockInterface};
use super::*;
use crate::context::tenant::with_default_tenant;
use crate::dao::GarrisonDao;
use crate::error::GarrisonError;
use crate::manager::GarrisonManager;
use crate::stp::{with_current_token, GarrisonInterface, GarrisonUtil};
use axum::body::Body;
use axum::extract::FromRequestParts;
use axum::http::Request;
use axum::http::StatusCode;
use axum::response::IntoResponse;
use serial_test::serial;
use std::sync::Arc;
struct AdminRole;
impl RoleName for AdminRole {
const NAME: &'static str = "admin";
}
struct UserRead;
impl PermissionName for UserRead {
const NAME: &'static str = "user:read";
}
fn make_config(throw_on_not_login: bool) -> crate::config::GarrisonConfig {
let mut config = crate::config::GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = throw_on_not_login;
config
}
async fn init_manager(
throw_on_not_login: bool,
permissions: &[(&str, &[&str])],
roles: &[(&str, &[&str])],
) {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config(throw_on_not_login));
let mut interface = MockInterface::new();
for (id, perms) in permissions {
interface = interface.with_permission(id, perms);
}
for (id, roles) in roles {
interface = interface.with_role(id, roles);
}
let interface: Arc<dyn GarrisonInterface> = Arc::new(interface);
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
}
fn make_parts() -> axum::http::request::Parts {
let req = Request::builder()
.method("GET")
.uri("/protected")
.body(Body::empty())
.unwrap();
req.into_parts().0
}
fn make_parts_with_bearer(token: &str) -> axum::http::request::Parts {
let req = Request::builder()
.method("GET")
.uri("/protected")
.header("authorization", format!("Bearer {}", token))
.body(Body::empty())
.unwrap();
req.into_parts().0
}
fn make_parts_with_garrison_header(token: &str) -> axum::http::request::Parts {
let req = Request::builder()
.method("GET")
.uri("/protected")
.header("garrison_token", token)
.body(Body::empty())
.unwrap();
req.into_parts().0
}
fn make_parts_with_cookie_token(token: &str) -> axum::http::request::Parts {
let config = crate::config::GarrisonConfig::default_config();
let cookie_name = crate::context::token_cookie_name(&config);
let req = Request::builder()
.method("GET")
.uri("/protected")
.header(
"cookie",
format!("other=val; {}={}; foo=bar", cookie_name, token),
)
.body(Body::empty())
.unwrap();
req.into_parts().0
}
#[tokio::test]
#[serial]
async fn check_login_logged_in_returns_ok() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts();
let result = with_current_token(token, async {
CheckLogin::from_request_parts(&mut parts, &()).await
})
.await;
assert!(result.is_ok(), "已登录应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_not_logged_in_returns_not_login() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts();
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"未登录且 throw_on_not_login=false 应返回 Err(NotLogin)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_not_logged_in_returns_session() {
init_manager(true, &[], &[]).await;
let mut parts = make_parts();
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::Session(_))),
"未登录且 throw_on_not_login=true 应返回 Err(Session)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_held_returns_ok() {
init_manager(true, &[], &[("1001", &["admin"])]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts();
let result = with_current_token(
token,
with_default_tenant(async {
CheckRole::<AdminRole>::from_request_parts(&mut parts, &()).await
}),
)
.await;
assert!(result.is_ok(), "持有角色应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_not_held_returns_not_role() {
init_manager(true, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts();
let result = with_current_token(
token,
with_default_tenant(async {
CheckRole::<AdminRole>::from_request_parts(&mut parts, &()).await
}),
)
.await;
assert!(
matches!(result, Err(GarrisonError::NotRole(_))),
"未持有角色应返回 Err(NotRole)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_held_returns_ok() {
init_manager(true, &[("1001", &["user:read"])], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts();
let result = with_current_token(token, async {
with_default_tenant(async {
CheckPermission::<UserRead>::from_request_parts(&mut parts, &()).await
})
.await
})
.await;
assert!(result.is_ok(), "持有权限应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_not_held_returns_not_permission() {
init_manager(true, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts();
let result = with_current_token(token, async {
with_default_tenant(async {
CheckPermission::<UserRead>::from_request_parts(&mut parts, &()).await
})
.await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"未持有权限应返回 Err(NotPermission)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn ignore_always_returns_ok() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts();
let result = Ignore::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "Ignore 应总是返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn mode_strict_not_logged_in_throws_not_login() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts();
let result = Mode::<Strict>::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"Mode<Strict> 未登录应抛 Err(NotLogin)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn mode_loose_not_logged_in_returns_ok() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts();
let result = Mode::<Loose>::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "Mode<Loose> 未登录应返回 Ok");
GarrisonManager::reset_for_test();
}
#[test]
fn not_login_returns_401() {
let err = GarrisonError::NotLogin("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn invalid_token_returns_401() {
let err = GarrisonError::InvalidToken("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn expired_token_returns_401() {
let err = GarrisonError::ExpiredToken("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn not_permission_returns_403() {
let err = GarrisonError::NotPermission("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn not_role_returns_403() {
let err = GarrisonError::NotRole("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
#[test]
fn internal_error_returns_500() {
let err = GarrisonError::Internal("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn session_error_returns_500() {
let err = GarrisonError::Session("test".to_string());
let response = err.into_response();
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
}
#[test]
fn annotation_name_returns_variant_string() {
assert_eq!(Annotation::CheckLogin.name(), "CheckLogin");
assert_eq!(
Annotation::CheckPermission("p".to_string()).name(),
"CheckPermission"
);
assert_eq!(Annotation::CheckRole("r".to_string()).name(), "CheckRole");
assert_eq!(Annotation::CheckSafe.name(), "CheckSafe");
assert_eq!(Annotation::CheckDisable.name(), "CheckDisable");
assert_eq!(Annotation::CheckOr.name(), "CheckOr");
assert_eq!(Annotation::CheckAnd.name(), "CheckAnd");
assert_eq!(Annotation::CheckNot.name(), "CheckNot");
assert_eq!(Annotation::Ignore.name(), "Ignore");
assert_eq!(Annotation::CheckBasicAuth.name(), "CheckBasicAuth");
assert_eq!(Annotation::CheckDigestAuth.name(), "CheckDigestAuth");
assert_eq!(Annotation::CheckSign.name(), "CheckSign");
assert_eq!(
Annotation::CheckApiKey { namespace: None }.name(),
"CheckApiKey"
);
assert_eq!(
Annotation::CheckApiKey {
namespace: Some("ns1".to_string())
}
.name(),
"CheckApiKey"
);
assert_eq!(Annotation::Mode(AnnotationMode::And).name(), "Mode");
assert_eq!(Annotation::Mode(AnnotationMode::Or).name(), "Mode");
assert_eq!(Annotation::CheckAccessToken.name(), "CheckAccessToken");
assert_eq!(Annotation::CheckClientToken.name(), "CheckClientToken");
}
#[test]
fn annotation_mode_display_outputs_uppercase() {
assert_eq!(format!("{}", AnnotationMode::And), "AND");
assert_eq!(format!("{}", AnnotationMode::Or), "OR");
}
#[test]
fn annotation_mode_copy_semantics() {
let mode = AnnotationMode::And;
let copied = mode;
assert_eq!(mode, AnnotationMode::And);
assert_eq!(copied, AnnotationMode::And);
}
#[test]
fn annotation_mode_equality_within_annotation() {
assert_eq!(
Annotation::Mode(AnnotationMode::And),
Annotation::Mode(AnnotationMode::And)
);
assert_ne!(
Annotation::Mode(AnnotationMode::And),
Annotation::Mode(AnnotationMode::Or)
);
}
#[test]
fn check_api_key_namespace_equality() {
assert_eq!(
Annotation::CheckApiKey { namespace: None },
Annotation::CheckApiKey { namespace: None }
);
assert_ne!(
Annotation::CheckApiKey { namespace: None },
Annotation::CheckApiKey {
namespace: Some("ns1".to_string())
}
);
assert_ne!(
Annotation::CheckApiKey {
namespace: Some("ns1".to_string())
},
Annotation::CheckApiKey {
namespace: Some("ns2".to_string())
}
);
}
#[test]
fn check_access_token_display_formats_correctly() {
assert_eq!(
format!("{}", Annotation::CheckAccessToken),
"CheckAccessToken"
);
}
#[test]
fn check_client_token_display_formats_correctly() {
assert_eq!(
format!("{}", Annotation::CheckClientToken),
"CheckClientToken"
);
}
#[test]
fn check_access_token_from_str_returns_ok() {
let result: Result<Annotation, _> = "CheckAccessToken".parse();
assert!(result.is_ok(), "from_str 应返回 Ok");
assert_eq!(result.unwrap(), Annotation::CheckAccessToken);
}
#[test]
fn check_client_token_from_str_returns_ok() {
let result: Result<Annotation, _> = "CheckClientToken".parse();
assert!(result.is_ok(), "from_str 应返回 Ok");
assert_eq!(result.unwrap(), Annotation::CheckClientToken);
}
#[test]
fn annotation_from_str_unknown_returns_err() {
let result: Result<Annotation, _> = "UnknownAnnotation".parse();
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"未知注解应返回 Err(InvalidParam),实际: {:?}",
result
);
}
#[test]
fn annotation_from_str_data_variant_returns_err() {
let result: Result<Annotation, _> = "CheckPermission".parse();
assert!(
result.is_err(),
"含数据变体应返回 Err(无法仅从名称解析),实际: {:?}",
result
);
}
#[serial]
#[test]
fn display_matches_name_for_all_unit_variants() {
let unit_variants = [
Annotation::CheckLogin,
Annotation::CheckSafe,
Annotation::CheckDisable,
Annotation::CheckOr,
Annotation::CheckAnd,
Annotation::CheckNot,
Annotation::Ignore,
Annotation::CheckBasicAuth,
Annotation::CheckDigestAuth,
Annotation::CheckSign,
Annotation::CheckAccessToken,
Annotation::CheckClientToken,
];
for ann in &unit_variants {
assert_eq!(
format!("{}", ann),
ann.name(),
"Display 输出应与 name() 一致"
);
}
}
#[tokio::test]
#[serial]
async fn check_login_extracts_token_from_bearer_header() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "Bearer header 提取 token 后校验应通过");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_extracts_token_from_garrison_header() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_garrison_header(&token);
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(
result.is_ok(),
"garrison_token header 提取 token 后校验应通过"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_extracts_token_from_cookie() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_cookie_token(&token);
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "Cookie 提取 token 后校验应通过");
GarrisonManager::reset_for_test();
}
#[cfg(feature = "production")]
#[tokio::test]
#[serial]
async fn check_login_extracts_token_from_host_prefixed_cookie() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let config = GarrisonUtil::config().unwrap();
let cookie_name = crate::context::token_cookie_name(&config);
assert!(
cookie_name.starts_with("__Host-"),
"production 默认 Secure 上下文应为 __Host- 前缀名,实际: {}",
cookie_name
);
let req = Request::builder()
.method("GET")
.uri("/protected")
.header("cookie", format!("{}={}", cookie_name, token))
.body(Body::empty())
.unwrap();
let mut parts = req.into_parts().0;
let result = CheckLogin::from_request_parts(&mut parts, &()).await;
assert!(
result.is_ok(),
"__Host- 前缀 cookie 提取 token 后校验应通过"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_extracts_token_from_header() {
init_manager(true, &[], &[("1001", &["admin"])]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let result = with_default_tenant(async {
CheckRole::<AdminRole>::from_request_parts(&mut parts, &()).await
})
.await;
assert!(result.is_ok(), "持有角色时通过 header token 校验应通过");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_extracts_token_from_header() {
init_manager(true, &[("1001", &["user:read"])], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let result = with_default_tenant(async {
CheckPermission::<UserRead>::from_request_parts(&mut parts, &()).await
})
.await;
assert!(result.is_ok(), "持有权限时通过 header token 校验应通过");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn mode_strict_extracts_token_from_header() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let result = Mode::<Strict>::from_request_parts(&mut parts, &()).await;
assert!(
result.is_ok(),
"Mode<Strict> 已登录时通过 header token 校验应通过"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn mode_loose_logged_in_with_header() {
init_manager(false, &[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let result = Mode::<Loose>::from_request_parts(&mut parts, &()).await;
assert!(result.is_ok(), "Mode<Loose> 已登录时应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_extracts_login_id_from_bearer_header() {
init_manager(false, &[], &[]).await;
let login_id = "1001";
let token = GarrisonUtil::login_simple(login_id).await.unwrap();
let mut parts = make_parts_with_bearer(&token);
let principal = crate::context::GarrisonPrincipal::from_request_parts(&mut parts, &())
.await
.expect("有效 token 应解析出 GarrisonPrincipal");
assert_eq!(principal.login_id, login_id);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_err_without_token() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts();
let result = crate::context::GarrisonPrincipal::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"无 token 时应返回 Err(NotLogin),实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_err_with_invalid_token() {
init_manager(false, &[], &[]).await;
let mut parts = make_parts_with_bearer("invalid_token_xyz");
let result = crate::context::GarrisonPrincipal::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"无效 token 时应返回 Err(NotLogin),实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_err_when_token_logout() {
init_manager(false, &[], &[]).await;
let login_id = "1001";
let token = GarrisonUtil::login_simple(login_id).await.unwrap();
with_current_token(token.clone(), async {
GarrisonUtil::logout().await.unwrap();
})
.await;
let mut parts = make_parts_with_bearer(&token);
let result = crate::context::GarrisonPrincipal::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"token 已注销时应返回 Err(NotLogin),实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[cfg(feature = "tenant-isolation")]
#[tokio::test]
#[serial]
async fn tenant_context_extracts_tenant_id_from_header() {
let req = Request::builder()
.method("GET")
.uri("/api/test")
.header("x-tenant-id", "42")
.body(Body::empty())
.unwrap();
let mut parts = req.into_parts().0;
let ctx = crate::context::tenant::TenantContext::from_request_parts(&mut parts, &())
.await
.expect("有效 X-Tenant-Id 应解析出 TenantContext");
assert_eq!(ctx.tenant_id, 42);
assert!(
matches!(
ctx.resolved_from,
crate::context::tenant::TenantSource::Header
),
"resolved_from 应为 Header,实际 = {:?}",
ctx.resolved_from
);
}
#[cfg(feature = "tenant-isolation")]
#[tokio::test]
#[serial]
async fn tenant_context_returns_err_without_x_tenant_id_header() {
let mut parts = make_parts();
let result = crate::context::tenant::TenantContext::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::Config(_))),
"缺失 X-Tenant-Id 时应返回 Err(Config),实际 = {:?}",
result
);
}
#[cfg(feature = "tenant-isolation")]
#[tokio::test]
#[serial]
async fn tenant_context_returns_err_with_non_numeric_x_tenant_id() {
let req = Request::builder()
.method("GET")
.uri("/api/test")
.header("x-tenant-id", "not-a-number")
.body(Body::empty())
.unwrap();
let mut parts = req.into_parts().0;
let result = crate::context::tenant::TenantContext::from_request_parts(&mut parts, &()).await;
assert!(
matches!(result, Err(GarrisonError::Config(_))),
"非数字 X-Tenant-Id 时应返回 Err(Config),实际 = {:?}",
result
);
}
#[tokio::test]
async fn mock_interface_default_methods_with_type_coverage() {
let iface = MockInterface::new();
let _ = iface
.get_permission_list_with_type("u1", "default")
.await
.unwrap();
let _ = iface
.get_role_list_with_type("u1", "default")
.await
.unwrap();
}