garrison 0.9.0

Garrison - 面向 Rust 生态的一站式身份认证鉴权框架
Documentation
// Copyright (c) 2026 Kirky.X🌠
// SPDX-License-Identifier: Apache-2.0

//! warp Extractor 适配器:`garrison_principal`(Bearer token → `login_id`)与 `tenant_context`
//! (`tenant-isolation`,从 `X-Tenant-Id` 解析)。与 check_* Filter 互补:后者仅鉴权,本模块携带身份;
//! `GarrisonPrincipal` 类型定义在 [`crate::context`],与 actix extractor 共享。
//!
//! ## 使用示例
//!
//! ```ignore
//! use garrison::web_warp::garrison_principal;
//! use std::sync::Arc;
//! use garrison::config::GarrisonConfig;
//!
//! let config = Arc::new(GarrisonConfig::default_config());
//! let routes = warp::path("api")
//! .and(garrison_principal(config))
//! .map(|principal| format!("login_id = {}", principal.login_id));
//! ```

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;

// garrison_principal Filter:提取 login_id

/// `garrison_principal` Filter:从请求 header 提取 token 并解析 `login_id`(Extract 为
/// `(GarrisonPrincipal,)`,Error 为 `warp::Rejection`);无 token 或无效返回 `GarrisonRejection(NotLogin)`。
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 })
            }
        })
}

// tenant_context Filter(feature gate tenant-isolation)

/// `tenant_context` Filter:从 `X-Tenant-Id` header 解析 `TenantContext`;缺失或非合法 i64 返回
/// `GarrisonRejection(Config)`。
#[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();
    }

    // garrison_principal Filter 测试

    /// 从 `Authorization: Bearer <token>` header 解析出 `login_id`。
    #[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();
    }

    /// `garrison_principal` Filter 无 token 时返回 Rejection。
    #[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();
    }

    /// `garrison_principal` Filter 无效 token 时返回 Rejection。
    #[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();
    }
}

// TenantContext Filter 测试(feature gate tenant-isolation)

#[cfg(all(test, feature = "tenant-isolation"))]
mod tenant_tests {
    use crate::context::tenant::TenantSource;
    use serial_test::serial;

    /// `tenant_context` Filter 从 `X-Tenant-Id` header 解析出 `tenant_id`。
    #[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);
    }

    /// `tenant_context` Filter 无 `X-Tenant-Id` header 时返回 Rejection(显式失败)。
    #[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
        );
    }

    /// `tenant_context` Filter `X-Tenant-Id` 非数字时返回 Rejection(显式失败)。
    #[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
        );
    }
}