use super::mock::{MockDao, MockInterface};
use super::*;
use crate::context::tenant::with_default_tenant;
use crate::context::token_extract::extract_token_from_headers;
use crate::dao::GarrisonDao;
use crate::error::GarrisonResult;
use crate::manager::GarrisonManager;
use crate::stp::{GarrisonInterface, GarrisonUtil};
use serial_test::serial;
use warp::http::header;
use warp::http::header::HeaderValue;
use warp::http::StatusCode;
use warp::reply::Reply;
use warp::Filter;
#[test]
fn reply_not_login_returns_401() {
let err = GarrisonError::NotLogin("test".to_string());
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn reply_not_permission_returns_403() {
let err = GarrisonError::NotPermission("test".to_string());
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
}
#[test]
fn reply_not_role_returns_403() {
let err = GarrisonError::NotRole("test".to_string());
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
}
#[test]
fn reply_invalid_token_returns_401() {
let err = GarrisonError::InvalidToken("test".to_string());
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn reply_not_implemented_returns_501() {
let err = GarrisonError::NotImplemented("test".to_string());
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::NOT_IMPLEMENTED);
}
#[test]
fn reply_exception_code_minus1_returns_401() {
let ex = crate::exception::GarrisonException::new(-1, "未登录");
let err = GarrisonError::Exception(Box::new(ex));
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
}
#[test]
fn reply_exception_code_minus2_returns_403() {
let ex = crate::exception::GarrisonException::new(-2, "无权限");
let err = GarrisonError::Exception(Box::new(ex));
let resp = err.into_response();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
}
#[test]
fn reply_returns_json_content_type() {
let err = GarrisonError::NotLogin("internal detail".to_string());
let resp = err.into_response();
assert_eq!(
resp.headers()
.get("content-type")
.and_then(|v| v.to_str().ok()),
Some("application/json")
);
}
#[test]
fn extract_token_from_bearer_header() {
let mut headers = warp::http::HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer my_token_123"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("my_token_123".to_string()));
}
#[test]
fn extract_token_bearer_case_insensitive() {
let config = GarrisonConfig::default_config();
for prefix in &["Bearer", "bearer", "BEARER", "BeArEr"] {
let mut headers = warp::http::HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_str(&format!("{} tok_{}", prefix, prefix)).unwrap(),
);
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(
token,
Some(format!("tok_{}", prefix)),
"前缀 '{}' 应能提取 token",
prefix
);
}
}
#[test]
fn extract_token_from_cookie() {
let mut headers = warp::http::HeaderMap::new();
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok_456"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("cookie_tok_456".to_string()));
}
#[test]
fn extract_token_returns_none_when_missing() {
let headers = warp::http::HeaderMap::new();
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, None);
}
#[test]
fn extract_token_header_priority_over_cookie() {
let mut headers = warp::http::HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
headers.insert(
header::COOKIE,
HeaderValue::from_static("garrison_token=cookie_tok"),
);
let config = GarrisonConfig::default_config();
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, Some("header_tok".to_string()));
}
#[test]
fn extract_token_skips_header_when_disabled() {
let mut headers = warp::http::HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
HeaderValue::from_static("Bearer header_tok"),
);
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
let token = extract_token_from_headers(&headers, &config).unwrap();
assert_eq!(token, None);
}
#[test]
fn rejection_wraps_error() {
let err = GarrisonError::NotLogin("test".to_string());
let rej = GarrisonRejection(err);
assert!(format!("{:?}", rej).contains("NotLogin"));
}
#[test]
fn router_new_initializes_defaults() {
let router = GarrisonRouter::new(Arc::new(GarrisonConfig::default_config()));
assert!(router.rules.is_empty());
}
#[test]
fn router_route_protected_adds_rule() {
let router = GarrisonRouter::new(Arc::new(GarrisonConfig::default_config()))
.route_protected("/api/user", Annotation::CheckLogin)
.route_protected("/api/admin", Annotation::CheckRole("admin".to_string()));
assert_eq!(router.rules.len(), 2);
assert!(router.rules.contains_key("/api/user"));
assert!(router.rules.contains_key("/api/admin"));
}
#[test]
fn router_with_interceptor_replaces_default() {
struct CustomInterceptor;
#[async_trait::async_trait]
impl GarrisonInterceptor for CustomInterceptor {
async fn pre_handle(&self, _path: &str, _annotation: &Annotation) -> GarrisonResult<()> {
Ok(())
}
}
let router = GarrisonRouter::new(Arc::new(GarrisonConfig::default_config()))
.with_interceptor(CustomInterceptor);
assert!(Arc::strong_count(&router.interceptor) >= 1);
}
#[test]
fn router_default_impl() {
let router = GarrisonRouter::default();
assert!(router.rules.is_empty());
}
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();
}
#[tokio::test]
#[serial]
async fn into_filter_allows_unprotected_path() {
init_manager(&[], &[]).await;
let router = GarrisonRouter::new(Arc::new(make_config()))
.route_protected("/protected", Annotation::CheckLogin);
let filter = router.into_filter();
let result = warp::test::request()
.path("/unprotected")
.filter(&filter)
.await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn into_filter_blocks_protected_path_without_token() {
init_manager(&[], &[]).await;
let router = GarrisonRouter::new(Arc::new(make_config()))
.route_protected("/protected", Annotation::CheckLogin);
let filter = router.into_filter();
let result = warp::test::request()
.path("/protected")
.filter(&filter)
.await;
assert!(result.is_err());
let rej = result.unwrap_err();
assert!(rej.find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn into_filter_allows_protected_path_with_valid_token() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let router = GarrisonRouter::new(Arc::new(make_config()))
.route_protected("/protected", Annotation::CheckLogin);
let filter = router.into_filter();
let result = warp::test::request()
.path("/protected")
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn into_filter_blocks_permission_denied() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let router = GarrisonRouter::new(Arc::new(make_config())).route_protected(
"/admin",
Annotation::CheckPermission("admin:read".to_string()),
);
let filter = router.into_filter();
let result = warp::test::request()
.path("/admin")
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await;
assert!(result.is_err());
let rej = result.unwrap_err();
assert!(rej.find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn into_filter_allows_ignore_path_without_token() {
init_manager(&[], &[]).await;
let router =
GarrisonRouter::new(Arc::new(make_config())).route_protected("/public", Annotation::Ignore);
let filter = router.into_filter();
let result = warp::test::request().path("/public").filter(&filter).await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_filter_rejects_without_token() {
init_manager(&[], &[]).await;
let filter = check_login(Arc::new(make_config()));
let result = warp::test::request().filter(&filter).await;
assert!(result.is_err());
let rej = result.unwrap_err();
assert!(rej.find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_login_filter_passes_with_valid_token() {
init_manager(&[], &[]).await;
let token = GarrisonUtil::login_simple("1001").await.unwrap();
let filter = check_login(Arc::new(make_config()));
let result = warp::test::request()
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_filter_rejects_without_token() {
init_manager(&[], &[]).await;
let filter = check_role(Arc::new(make_config()), "admin".to_string());
let result = warp::test::request().filter(&filter).await;
assert!(result.is_err());
assert!(result.unwrap_err().find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_filter_rejects_without_role() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let filter = check_role(Arc::new(make_config()), "admin".to_string());
let result = with_default_tenant(async {
warp::test::request()
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await
})
.await;
assert!(result.is_err());
assert!(result.unwrap_err().find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_role_filter_passes_with_valid_role() {
init_manager(&[], &[("1001", &["admin"])]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let filter = check_role(Arc::new(make_config()), "admin".to_string());
let result = with_default_tenant(async {
warp::test::request()
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await
})
.await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_filter_rejects_without_token() {
init_manager(&[], &[]).await;
let filter = check_permission(Arc::new(make_config()), "user:read".to_string());
let result = warp::test::request().filter(&filter).await;
assert!(result.is_err());
assert!(result.unwrap_err().find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_filter_rejects_without_permission() {
init_manager(&[], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let filter = check_permission(Arc::new(make_config()), "user:read".to_string());
let result = warp::test::request()
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await;
assert!(result.is_err());
assert!(result.unwrap_err().find::<GarrisonRejection>().is_some());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn check_permission_filter_passes_with_valid_permission() {
init_manager(&[("1001", &["user:read"])], &[]).await; let token = GarrisonUtil::login_simple("1001").await.unwrap();
let filter = check_permission(Arc::new(make_config()), "user:read".to_string());
let result = with_default_tenant(async {
warp::test::request()
.header("authorization", format!("Bearer {}", token))
.filter(&filter)
.await
})
.await;
assert!(result.is_ok());
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn warp_serve_unauthenticated_returns_unified_401_json() {
init_manager(&[], &[]).await;
let config = Arc::new(make_config());
let protected = warp::get()
.and(warp::path("protected"))
.and(warp::path::end())
.and(check_login(config))
.map(|()| "ok");
let routes = protected.recover(garrison_recover);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("应能绑定临时端口");
let addr = listener.local_addr().expect("应能取得实际地址");
let server = tokio::spawn(warp::serve(routes).incoming(listener).run());
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
let client = reqwest::Client::new();
let url = format!("http://{}/protected", addr);
let resp = client.get(&url).send().await.expect("请求应送达");
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED, "未登录应返回 401");
let body: serde_json::Value = resp.json().await.expect("body 应为 JSON");
assert!(
body.get("error_code").is_some(),
"响应应含 error_code 字段(三框架一致),实际: {body}"
);
assert!(
body.get("message").is_some(),
"响应应含 message 字段(三框架一致),实际: {body}"
);
let token = GarrisonUtil::login_simple("1001")
.await
.expect("login 应签发 token");
let resp = client
.get(&url)
.header(header::AUTHORIZATION, format!("Bearer {}", token))
.send()
.await
.expect("请求应送达");
assert_eq!(resp.status(), StatusCode::OK, "有效 token 应放行 200");
server.abort();
GarrisonManager::reset_for_test();
}