use super::mock::{MockDao, MockInterface};
use super::*;
use crate::annotation::Annotation;
use crate::config::GarrisonConfig;
use crate::context::tenant::with_default_tenant;
use crate::dao::GarrisonDao;
use crate::error::GarrisonError;
use crate::manager::GarrisonManager;
use crate::stp::context::set_renewed_token;
use crate::stp::{GarrisonInterface, GarrisonUtil};
use async_trait::async_trait;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use serial_test::serial;
use std::sync::Arc;
use tower::ServiceExt;
fn make_config() -> GarrisonConfig {
let mut config = GarrisonConfig::default_config();
config.timeout = 3600;
config.active_timeout = -1;
config.throw_on_not_login = false;
config
}
async fn init_manager(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());
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();
}
#[cfg_attr(not(feature = "protocol-apikey"), allow(dead_code))]
async fn init_manager_with_dao() -> Arc<MockDao> {
GarrisonManager::reset_for_test();
let dao = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao.clone() as Arc<dyn GarrisonDao>)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
dao
}
fn make_request(path: &str, token: Option<&str>) -> Request<Body> {
let mut builder = Request::builder().method("GET").uri(path);
if let Some(t) = token {
builder = builder.header("Authorization", format!("Bearer {}", t));
}
builder.body(Body::empty()).unwrap()
}
fn make_router() -> GarrisonRouter {
GarrisonRouter::new(Arc::new(make_config()))
.route_protected("/protected", || async { "ok" }, Annotation::CheckLogin)
.route_protected(
"/admin",
|| async { "admin ok" },
Annotation::CheckRole("admin".to_string()),
)
.route_protected(
"/users",
|| async { "users ok" },
Annotation::CheckPermission("user:read".to_string()),
)
.route_protected("/public", || async { "public ok" }, Annotation::Ignore)
}
#[tokio::test]
#[serial]
async fn route_protected_build_handles_request() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response = app
.oneshot(make_request("/protected", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn protected_without_token_returns_401() {
init_manager(&[], &[]).await;
let app = make_router().build();
let response = app.oneshot(make_request("/protected", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn protected_with_valid_token_returns_200() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response = app
.oneshot(make_request("/protected", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn protected_with_invalid_token_returns_401() {
init_manager(&[], &[]).await;
let app = make_router().build();
let response = app
.oneshot(make_request("/protected", Some("invalid-token")))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn permission_denied_returns_403() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response = with_default_tenant(async {
app.oneshot(make_request("/users", Some(&token)))
.await
.unwrap()
})
.await;
assert_eq!(response.status(), StatusCode::FORBIDDEN);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn permission_granted_returns_200() {
init_manager(&[("1001", &["user:read"])], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response = with_default_tenant(async {
app.oneshot(make_request("/users", Some(&token)))
.await
.unwrap()
})
.await;
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn role_denied_returns_403() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response =
with_default_tenant(async { app.oneshot(make_request("/admin", Some(&token))).await })
.await
.unwrap();
assert_eq!(response.status(), StatusCode::FORBIDDEN);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn role_granted_returns_200() {
init_manager(&[], &[("1001", &["admin"])]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response =
with_default_tenant(async { app.oneshot(make_request("/admin", Some(&token))).await })
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn ignore_allows_anonymous_access() {
init_manager(&[], &[]).await;
let app = make_router().build();
let response = app.oneshot(make_request("/public", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn middleware_extracts_token_from_bearer_header() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = make_router().build();
let response = app
.oneshot(make_request("/protected", Some(&token)))
.await
.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"Bearer header 提取 token 后应通过鉴权"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn middleware_extracts_token_from_custom_header() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let req = Request::builder()
.method("GET")
.uri("/protected")
.header("garrison_token", &token)
.body(Body::empty())
.unwrap();
let app = make_router().build();
let response = app.oneshot(req).await.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"自定义 token_name header 提取 token 后应通过鉴权"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn middleware_extracts_token_from_cookie() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let cookie_value = format!(
"{}={}",
crate::context::token_cookie_name(&make_config()),
token
);
let req = Request::builder()
.method("GET")
.uri("/protected")
.header("Cookie", cookie_value)
.body(Body::empty())
.unwrap();
let app = make_router().build();
let response = app.oneshot(req).await.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"cookie 提取 token 后应通过鉴权"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_login_logged_in_ok() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let interceptor = DefaultGarrisonInterceptor;
let result = crate::stp::with_current_token(
token,
interceptor.pre_handle("/x", &Annotation::CheckLogin),
)
.await;
assert!(result.is_ok(), "已登录 pre_handle(CheckLogin) 应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_login_not_logged_in_err() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor.pre_handle("/x", &Annotation::CheckLogin).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"未登录 pre_handle(CheckLogin) 应返回 Err(NotLogin)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_role_held_ok() {
init_manager(&[], &[("1001", &["admin"])]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let interceptor = DefaultGarrisonInterceptor;
let result = crate::stp::with_current_token(
token,
with_default_tenant(
interceptor.pre_handle("/x", &Annotation::CheckRole("admin".to_string())),
),
)
.await;
assert!(result.is_ok(), "持有角色 pre_handle(CheckRole) 应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_permission_not_held_err() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let interceptor = DefaultGarrisonInterceptor;
let result = crate::stp::with_current_token(
token,
with_default_tenant(async {
interceptor
.pre_handle("/x", &Annotation::CheckPermission("user:read".to_string()))
.await
}),
)
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"未持有权限 pre_handle(CheckPermission) 应返回 Err(NotPermission)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_ignore_returns_ok() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor.pre_handle("/x", &Annotation::Ignore).await;
assert!(result.is_ok(), "pre_handle(Ignore) 应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_logical_combinator_annotations_returns_ok() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let combinators = [
Annotation::CheckOr,
Annotation::CheckAnd,
Annotation::CheckNot,
];
for ann in &combinators {
let result = interceptor.pre_handle("/x", ann).await;
assert!(
result.is_ok(),
"pre_handle({:?}) 逻辑组合注解应通过 catch-all 分支返回 Ok",
ann
);
}
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_safe_returns_ok_by_default() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor.pre_handle("/x", &Annotation::CheckSafe).await;
#[cfg(feature = "security-extra")]
{
assert!(
matches!(result, Err(GarrisonError::NotSafe { .. })),
"启用 safe-auth 时未登录,pre_handle(CheckSafe) 应返回 Err(NotSafe),实际: {:?}",
result
);
}
#[cfg(not(feature = "security-extra"))]
{
assert!(
result.is_ok(),
"未启用 safe-auth 时 pre_handle(CheckSafe) 应返回 Ok,实际: {:?}",
result
);
}
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_disable_returns_ok_by_default() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckDisable)
.await;
assert!(result.is_ok(), "默认 check_disable(未禁用账号)应返回 Ok");
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_basic_auth_returns_not_implemented() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckBasicAuth)
.await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(_))),
"CheckBasicAuth 应返回 NotImplemented(pre_handle 缺少 HTTP 请求上下文)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_digest_auth_returns_not_implemented() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckDigestAuth)
.await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(_))),
"CheckDigestAuth 应返回 NotImplemented(pre_handle 缺少 HTTP 请求上下文)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_sign_returns_not_implemented() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor.pre_handle("/x", &Annotation::CheckSign).await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(_))),
"CheckSign 应返回 NotImplemented(pre_handle 缺少 HTTP 请求上下文)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_basic_auth_error_message_contains_guidance() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckBasicAuth)
.await;
if let Err(GarrisonError::NotImplemented(msg)) = result {
assert!(
msg.contains("router-check-basic-auth-need-http-context"),
"错误消息应包含使用建议,实际: {}",
msg
);
}
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_access_token_returns_not_implemented() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckAccessToken)
.await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(_))),
"CheckAccessToken 无 OAuth2Handler 时应返回 NotImplemented,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_client_token_returns_not_implemented() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckClientToken)
.await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(_))),
"CheckClientToken 无 OAuth2Handler 时应返回 NotImplemented,实际: {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_interceptor_check_access_token_error_contains_guidance() {
init_manager(&[], &[]).await;
let interceptor = DefaultGarrisonInterceptor;
let result = interceptor
.pre_handle("/x", &Annotation::CheckAccessToken)
.await;
if let Err(GarrisonError::NotImplemented(msg)) = result {
assert!(
msg.contains("router-check-access-token-need-oauth2"),
"错误消息应包含 OAuth2 使用建议,实际: {}",
msg
);
}
GarrisonManager::reset_for_test();
}
struct CountingInterceptor {
count: std::sync::Arc<std::sync::atomic::AtomicU32>,
}
impl CountingInterceptor {
fn new() -> (Self, std::sync::Arc<std::sync::atomic::AtomicU32>) {
let count = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(0));
(
Self {
count: count.clone(),
},
count,
)
}
}
#[async_trait]
impl GarrisonInterceptor for CountingInterceptor {
async fn pre_handle(&self, _path: &str, _annotation: &Annotation) -> GarrisonResult<()> {
self.count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
Ok(())
}
}
#[tokio::test]
#[serial]
async fn with_interceptor_uses_custom_interceptor() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let (interceptor, count) = CountingInterceptor::new();
assert_eq!(
count.load(std::sync::atomic::Ordering::SeqCst),
0,
"初始调用次数应为 0"
);
let app = GarrisonRouter::new(Arc::new(make_config()))
.with_interceptor(interceptor)
.route_protected("/protected", || async { "ok" }, Annotation::CheckLogin)
.build();
let response = app
.oneshot(make_request("/protected", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
count.load(std::sync::atomic::Ordering::SeqCst),
1,
"自定义拦截器的 pre_handle 应在请求后被调用一次"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn default_router_handles_request() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = GarrisonRouter::default()
.route_protected("/protected", || async { "ok" }, Annotation::CheckLogin)
.build();
let response = app
.oneshot(make_request("/protected", Some(&token)))
.await
.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"Default 创建的 router 应能正常处理请求"
);
GarrisonManager::reset_for_test();
}
#[cfg(feature = "tenant-isolation")]
#[serial]
#[tokio::test]
async fn tenant_resolution_middleware_sets_tenant_context() {
use crate::context::tenant::{HeaderTenantResolver, TenantResolver, TENANT};
use axum::routing::get;
use axum::Router;
use tower::ServiceExt;
async fn handler() -> String {
match TENANT.try_get() {
Ok(ctx) => format!("tenant:{}", ctx.tenant_id),
Err(_) => "no-tenant".to_string(),
}
}
let resolver: Arc<dyn TenantResolver> = Arc::new(HeaderTenantResolver);
let app =
Router::new()
.route("/test", get(handler))
.layer(axum::middleware::from_fn_with_state(
resolver,
super::tenant_resolution_middleware,
));
let req = Request::builder()
.method("GET")
.uri("/test")
.header("X-Tenant-Id", "42")
.body(Body::empty())
.unwrap();
let resp = app.oneshot(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let body = axum::body::to_bytes(resp.into_body(), usize::MAX)
.await
.unwrap();
let body_str = String::from_utf8(body.to_vec()).unwrap();
assert_eq!(
body_str, "tenant:42",
"middleware 应设置 TENANT 上下文,handler 应读到 tenant_id=42"
);
}
#[cfg(feature = "tenant-isolation")]
#[serial]
#[tokio::test]
async fn tenant_resolution_middleware_missing_header_returns_400() {
use crate::context::tenant::{HeaderTenantResolver, TenantResolver};
use axum::routing::get;
use axum::Router;
use tower::ServiceExt;
async fn handler() -> &'static str {
"should-not-reach"
}
let resolver: Arc<dyn TenantResolver> = Arc::new(HeaderTenantResolver);
let app =
Router::new()
.route("/test", get(handler))
.layer(axum::middleware::from_fn_with_state(
resolver,
super::tenant_resolution_middleware,
));
let req = Request::builder()
.method("GET")
.uri("/test")
.body(Body::empty())
.unwrap();
let resp = app.oneshot(req).await.unwrap();
assert_eq!(
resp.status(),
StatusCode::BAD_REQUEST,
"缺失 X-Tenant-Id header 应返回 400 Bad Request"
);
}
#[cfg(feature = "protocol-apikey")]
#[tokio::test]
#[serial]
async fn check_api_key_with_valid_key_returns_200() {
use crate::protocol::apikey::ApiKeyHandler;
let dao = init_manager_with_dao().await;
let handler = ApiKeyHandler::new(dao.clone() as Arc<dyn GarrisonDao>);
let key = handler
.generate_with_namespace("user1", "ns1", vec![], 3600)
.await
.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.route_protected(
"/api",
|| async { "api ok" },
Annotation::CheckApiKey {
namespace: Some("ns1".to_string()),
},
)
.build();
let response = app.oneshot(make_request("/api", Some(&key))).await.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"有效 API Key + 正确 namespace 应返回 200"
);
GarrisonManager::reset_for_test();
}
#[cfg(feature = "protocol-apikey")]
#[tokio::test]
#[serial]
async fn check_api_key_without_key_returns_401() {
init_manager_with_dao().await;
let app = GarrisonRouter::new(Arc::new(make_config()))
.route_protected(
"/api",
|| async { "api ok" },
Annotation::CheckApiKey {
namespace: Some("ns1".to_string()),
},
)
.build();
let response = app.oneshot(make_request("/api", None)).await.unwrap();
assert_eq!(
response.status(),
StatusCode::UNAUTHORIZED,
"无 API Key 应返回 401"
);
GarrisonManager::reset_for_test();
}
#[cfg(feature = "protocol-apikey")]
#[tokio::test]
#[serial]
async fn check_api_key_namespace_mismatch_returns_401() {
use crate::protocol::apikey::ApiKeyHandler;
let dao = init_manager_with_dao().await;
let handler = ApiKeyHandler::new(dao.clone() as Arc<dyn GarrisonDao>);
let key = handler
.generate_with_namespace("user1", "ns1", vec![], 3600)
.await
.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.route_protected(
"/api",
|| async { "api ok" },
Annotation::CheckApiKey {
namespace: Some("ns2".to_string()),
},
)
.build();
let response = app.oneshot(make_request("/api", Some(&key))).await.unwrap();
assert_eq!(
response.status(),
StatusCode::UNAUTHORIZED,
"ns1 key 访问 ns2 路由应返回 401(namespace 隔离)"
);
GarrisonManager::reset_for_test();
}
#[cfg(feature = "protocol-apikey")]
#[tokio::test]
#[serial]
async fn check_api_key_none_namespace_uses_default() {
use crate::protocol::apikey::ApiKeyHandler;
let dao = init_manager_with_dao().await;
let handler = ApiKeyHandler::new(dao.clone() as Arc<dyn GarrisonDao>);
let key = handler.generate("user1", vec![], 3600).await.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.route_protected(
"/api",
|| async { "api ok" },
Annotation::CheckApiKey { namespace: None },
)
.build();
let response = app.oneshot(make_request("/api", Some(&key))).await.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"namespace=None 应使用默认命名空间 default,有效 key 应返回 200"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn mode_annotation_is_noop_in_pre_handle() {
use crate::annotation::AnnotationMode;
init_manager(&[], &[]).await;
let app = GarrisonRouter::new(Arc::new(make_config()))
.route_protected(
"/mode",
|| async { "mode ok" },
Annotation::Mode(AnnotationMode::And),
)
.build();
let response = app.oneshot(make_request("/mode", None)).await.unwrap();
assert_eq!(
response.status(),
StatusCode::OK,
"Mode 注解 pre_handle 为 no-op,应直接放行"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn group_applies_prefix_to_sub_routes() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/api/v1", Annotation::CheckLogin, |r| {
r.route_protected("/users", || async { "users ok" }, Annotation::CheckLogin)
})
.build();
let response = app
.clone()
.oneshot(make_request("/api/v1/users", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let response = app
.oneshot(make_request("/api/v1/users", None))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn group_with_ignore_annotation_overrides_route_annotation() {
init_manager(&[], &[]).await;
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/public", Annotation::Ignore, |r| {
r.route_protected("/data", || async { "data ok" }, Annotation::CheckLogin)
})
.build();
let response = app
.oneshot(make_request("/public/data", None))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn group_non_ignore_annotation_preserves_route_annotation() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/api", Annotation::CheckLogin, |r| {
r.route_protected(
"/admin",
|| async { "admin ok" },
Annotation::CheckRole("admin".to_string()),
)
})
.build();
let response =
with_default_tenant(async { app.oneshot(make_request("/api/admin", Some(&token))).await })
.await
.unwrap();
assert_eq!(
response.status(),
StatusCode::FORBIDDEN,
"group 非 Ignore 注解应保留路由自身注解(CheckRole),已登录但无角色应 403"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn group_nested_merges_prefixes() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/api", Annotation::CheckLogin, |r| {
r.group("/v1", Annotation::CheckLogin, |r| {
r.route_protected("/users", || async { "users ok" }, Annotation::CheckLogin)
})
})
.build();
let response = app
.clone()
.oneshot(make_request("/api/v1/users", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let response = app
.oneshot(make_request("/api/v1/users", None))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
GarrisonManager::reset_for_test();
}
#[test]
#[should_panic(expected = "prefix must not be empty")]
fn group_empty_prefix_panics() {
let _ = GarrisonRouter::new(Arc::new(make_config())).group("", Annotation::Ignore, |r| r);
}
#[tokio::test]
#[serial]
async fn group_trailing_slash_trimmed() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/api/v1/", Annotation::CheckLogin, |r| {
r.route_protected("/users", || async { "users ok" }, Annotation::CheckLogin)
})
.build();
let response = app
.oneshot(make_request("/api/v1/users", Some(&token)))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn group_chained_calls_register_separate_prefixes() {
init_manager(&[], &[]).await;
let app = GarrisonRouter::new(Arc::new(make_config()))
.group("/api/v1", Annotation::Ignore, |r| {
r.route_protected("/users", || async { "v1 users" }, Annotation::Ignore)
})
.group("/api/v2", Annotation::Ignore, |r| {
r.route_protected("/users", || async { "v2 users" }, Annotation::Ignore)
})
.build();
let response = app
.clone()
.oneshot(make_request("/api/v1/users", None))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let response = app
.oneshot(make_request("/api/v2/users", None))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
GarrisonManager::reset_for_test();
}
struct RenewingInterceptor {
new_token: String,
}
#[async_trait]
impl GarrisonInterceptor for RenewingInterceptor {
async fn pre_handle(&self, _path: &str, _annotation: &Annotation) -> GarrisonResult<()> {
set_renewed_token(self.new_token.clone());
Ok(())
}
}
#[tokio::test]
#[serial]
async fn renewed_token_written_to_header() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = true;
config.is_write_cookie = false;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "renewed-header-token".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let header = response
.headers()
.get("garrison_token")
.expect("is_write_header=true 时响应应包含续签 header");
assert_eq!(
header.to_str().unwrap(),
"renewed-header-token",
"header 值应为续签 token"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_token_written_to_cookie() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = true;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "renewed-cookie-token".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let cookie = response
.headers()
.get("set-cookie")
.expect("is_write_cookie=true 时响应应包含 Set-Cookie");
let cookie_str = cookie.to_str().unwrap();
assert!(
cookie_str.contains("garrison_token=renewed-cookie-token"),
"Set-Cookie 应包含续签 token,实际: {}",
cookie_str
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_token_not_written_when_both_disabled() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = false;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "should-not-appear".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert!(
response.headers().get("garrison_token").is_none(),
"is_write_header=false 时不应有续签 header"
);
assert!(
response.headers().get("set-cookie").is_none(),
"is_write_cookie=false 时不应有 Set-Cookie"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_token_written_to_both_header_and_cookie() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = true;
config.is_write_cookie = true;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "dual-token".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let header = response
.headers()
.get("garrison_token")
.expect("is_write_header=true 时应有续签 header");
assert_eq!(header.to_str().unwrap(), "dual-token");
let cookie = response
.headers()
.get("set-cookie")
.expect("is_write_cookie=true 时应有 Set-Cookie");
assert!(
cookie
.to_str()
.unwrap()
.contains("garrison_token=dual-token"),
"Set-Cookie 应包含续签 token"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn no_renewed_token_nothing_written() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = true;
config.is_write_cookie = true;
let app = GarrisonRouter::new(Arc::new(config))
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert!(
response.headers().get("garrison_token").is_none(),
"无续签时不应有续签 header"
);
assert!(
response.headers().get("set-cookie").is_none(),
"无续签时不应有 Set-Cookie"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn clear_renewed_token_prevents_leak() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = true;
config.is_write_cookie = false;
let app1 = GarrisonRouter::new(Arc::new(config.clone()))
.with_interceptor(RenewingInterceptor {
new_token: "first-renewal".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let resp1 = app1.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(resp1.status(), StatusCode::OK);
assert!(
resp1.headers().get("garrison_token").is_some(),
"第一次请求应有续签 header"
);
let app2 = GarrisonRouter::new(Arc::new(config))
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let resp2 = app2.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(resp2.status(), StatusCode::OK);
assert!(
resp2.headers().get("garrison_token").is_none(),
"第二次请求不应有续签 header(clear_renewed_token 已清除)"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_cookie_none_insecure_downgrades_to_lax() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = true;
config.cookie_secure = false;
config.cookie_same_site = "None".to_string();
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "none-insecure-tok".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let cookie = response
.headers()
.get("set-cookie")
.expect("is_write_cookie=true 时应有 Set-Cookie");
let cookie_str = cookie.to_str().unwrap();
assert!(
cookie_str.contains("SameSite=Lax"),
"非 Secure 上下文应降级为 SameSite=Lax,实际: {}",
cookie_str
);
assert!(
!cookie_str.contains("SameSite=None"),
"不得输出 SameSite=None,实际: {}",
cookie_str
);
assert!(
!cookie_str.contains("Secure"),
"非 Secure 上下文不得输出 Secure,实际: {}",
cookie_str
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_cookie_with_injected_value_not_written() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = true;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "abc; Domain=evil.com".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert!(
response.headers().get("set-cookie").is_none(),
"续签 token 含注入字符时不应写入 Set-Cookie"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn renewed_cookie_invalid_same_site_not_written() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = true;
config.cookie_same_site = "weird".to_string();
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "invalid-samesite-tok".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert!(
response.headers().get("set-cookie").is_none(),
"非法 same_site 时不应写入 Set-Cookie"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn token_name_used_as_header_name() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.token_name = "custom_auth_token".to_string();
config.is_write_header = true;
config.is_write_cookie = false;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "custom-name-token".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let header = response
.headers()
.get("custom_auth_token")
.expect("应使用 config.token_name 作为 header 名");
assert_eq!(header.to_str().unwrap(), "custom-name-token");
assert!(
response.headers().get("garrison_token").is_none(),
"不应使用默认 token_name"
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn cookie_has_correct_attributes() {
init_manager(&[], &[]).await;
let mut config = make_config();
config.is_write_header = false;
config.is_write_cookie = true;
let app = GarrisonRouter::new(Arc::new(config))
.with_interceptor(RenewingInterceptor {
new_token: "attr-check-token".to_string(),
})
.route_protected("/test", || async { "ok" }, Annotation::Ignore)
.build();
let response = app.oneshot(make_request("/test", None)).await.unwrap();
assert_eq!(response.status(), StatusCode::OK);
let cookie = response
.headers()
.get("set-cookie")
.expect("应有 Set-Cookie header");
let cookie_str = cookie.to_str().unwrap();
assert!(
cookie_str.contains("HttpOnly"),
"Cookie 应包含 HttpOnly,实际: {}",
cookie_str
);
assert!(
cookie_str.contains("Path=/"),
"Cookie 应包含 Path=/,实际: {}",
cookie_str
);
assert!(
cookie_str.contains("SameSite=Lax"),
"Cookie 应包含 SameSite=Lax,实际: {}",
cookie_str
);
assert!(
cookie_str.contains("garrison_token=attr-check-token"),
"Cookie 应包含续签 token,实际: {}",
cookie_str
);
GarrisonManager::reset_for_test();
}
#[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();
}