use crate::config::GarrisonConfig;
use crate::context::token_extract::extract_token_from_headers;
use crate::context::GarrisonPrincipal;
use crate::error::GarrisonError;
use crate::stp::GarrisonUtil;
use std::sync::Arc;
use warp::http::HeaderMap;
use warp::Filter;
pub fn garrison_principal(
config: Arc<GarrisonConfig>,
) -> impl Filter<Extract = (GarrisonPrincipal,), Error = warp::Rejection> + Clone {
warp::any()
.and(warp::header::headers_cloned())
.and_then(move |headers: HeaderMap| {
let config = config.clone();
async move {
let token = extract_token_from_headers(&headers, &config)
.map_err(|e| warp::reject::custom(super::GarrisonRejection(e)))?
.ok_or_else(|| {
warp::reject::custom(super::GarrisonRejection(GarrisonError::NotLogin(
"web-not-login::".to_string(),
)))
})?;
let login_id = GarrisonUtil::get_login_id_by_token(&token)
.await
.map_err(|e| warp::reject::custom(super::GarrisonRejection(e)))?
.ok_or_else(|| {
warp::reject::custom(super::GarrisonRejection(GarrisonError::NotLogin(
"web-token-invalid::".to_string(),
)))
})?;
Ok::<GarrisonPrincipal, warp::Rejection>(GarrisonPrincipal { login_id })
}
})
}
#[cfg(feature = "tenant-isolation")]
pub fn tenant_context(
) -> impl Filter<Extract = (crate::context::tenant::TenantContext,), Error = warp::Rejection> + Clone
{
warp::any()
.and(warp::header::headers_cloned())
.and_then(|headers: HeaderMap| async move {
let raw = headers
.get("x-tenant-id")
.and_then(|v| v.to_str().ok())
.ok_or_else(|| {
warp::reject::custom(super::GarrisonRejection(GarrisonError::Config(
"ctx-tenant-id-missing::".into(),
)))
})?;
let tenant_id: i64 = raw.parse().map_err(|_| {
warp::reject::custom(super::GarrisonRejection(GarrisonError::Config(format!(
"ctx-tenant-id-invalid::{}",
raw
))))
})?;
Ok::<crate::context::tenant::TenantContext, warp::Rejection>(
crate::context::tenant::TenantContext {
tenant_id,
resolved_from: crate::context::tenant::TenantSource::Header,
},
)
})
}
#[cfg(test)]
mod tests {
use super::super::mock::{MockDao, MockInterface};
use super::*;
use crate::dao::GarrisonDao;
use crate::manager::GarrisonManager;
use crate::stp::{GarrisonInterface, GarrisonUtil};
use serial_test::serial;
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() {
GarrisonManager::reset_for_test();
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = Arc::new(make_config());
let interface: Arc<dyn GarrisonInterface> = Arc::new(MockInterface::new());
GarrisonManager::builder()
.dao(dao)
.config(config)
.interface(interface)
.build()
.await
.unwrap();
}
#[tokio::test]
#[serial]
async fn garrison_principal_extracted_from_warp_request() {
init_manager().await;
let login_id = "2002";
let token = GarrisonUtil::login_simple(login_id).await.unwrap();
let config = Arc::new(make_config());
let filter = garrison_principal(config);
let principal = warp::test::request()
.header("Authorization", format!("Bearer {}", token))
.filter(&filter)
.await
.expect("garrison_principal filter 应成功提取 GarrisonPrincipal");
assert_eq!(principal.login_id, login_id);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_rejection_without_token() {
init_manager().await;
let config = Arc::new(make_config());
let filter = garrison_principal(config);
let result = warp::test::request().filter(&filter).await;
assert!(
result.is_err(),
"无 token 时 filter 应返回 Err,实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
#[tokio::test]
#[serial]
async fn garrison_principal_returns_rejection_with_invalid_token() {
init_manager().await;
let config = Arc::new(make_config());
let filter = garrison_principal(config);
let result = warp::test::request()
.header("Authorization", "Bearer invalid_token_xyz")
.filter(&filter)
.await;
assert!(
result.is_err(),
"无效 token 时 filter 应返回 Err,实际 = {:?}",
result
);
GarrisonManager::reset_for_test();
}
}
#[cfg(all(test, feature = "tenant-isolation"))]
mod tenant_tests {
use crate::context::tenant::TenantSource;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn tenant_context_extracted_from_warp_request_when_tenant_isolation_enabled() {
let filter = super::tenant_context();
let ctx = warp::test::request()
.header("X-Tenant-Id", "42")
.filter(&filter)
.await
.expect("tenant_context filter 应成功提取 TenantContext");
assert_eq!(ctx.tenant_id, 42);
assert_eq!(ctx.resolved_from, TenantSource::Header);
}
#[tokio::test]
#[serial]
async fn tenant_context_returns_rejection_without_x_tenant_id_header() {
let filter = super::tenant_context();
let result = warp::test::request().filter(&filter).await;
assert!(
result.is_err(),
"无 X-Tenant-Id header 时 filter 应返回 Err,实际 = {:?}",
result
);
}
#[tokio::test]
#[serial]
async fn tenant_context_returns_rejection_with_non_numeric_x_tenant_id() {
let filter = super::tenant_context();
let result = warp::test::request()
.header("X-Tenant-Id", "not_a_number")
.filter(&filter)
.await;
assert!(
result.is_err(),
"X-Tenant-Id 非数字时 filter 应返回 Err,实际 = {:?}",
result
);
}
}