garrison 0.9.0

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

//! `grpc` 模块的 inline tests:覆盖 `GarrisonGrpcInterceptor` 的 token 提取、`Interceptor::call`
//! 行为、Clone/Debug trait 与 `health_service()`。

use super::*;
use tonic::metadata::MetadataMap;
use tonic::service::Interceptor;

#[test]
fn test_interceptor_new() {
    let _interceptor = GarrisonGrpcInterceptor::new();
    let _default: GarrisonGrpcInterceptor = Default::default();
}

#[test]
fn test_extract_token_bearer_success() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "Bearer abc123".parse().unwrap());
    let token = GarrisonGrpcInterceptor::extract_token(&metadata).unwrap();
    assert_eq!(token, "abc123");
}

/// extract_token 支持 "bearer"/"BEARER"/混合大小写 scheme(RFC 7235 大小写不敏感)。
#[test]
fn test_extract_token_bearer_lowercase() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "bearer xyz789".parse().unwrap());
    let token = GarrisonGrpcInterceptor::extract_token(&metadata).unwrap();
    assert_eq!(token, "xyz789");
}

#[test]
fn test_extract_token_bearer_uppercase() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "BEARER TOKEN123".parse().unwrap());
    let token = GarrisonGrpcInterceptor::extract_token(&metadata).unwrap();
    assert_eq!(token, "TOKEN123");
}

#[test]
fn test_extract_token_bearer_mixed_case() {
    for header in ["BeArEr tok1", "bEaReR tok2", "BEARER tok3", "bearer tok4"] {
        let mut metadata = MetadataMap::new();
        metadata.insert("authorization", header.parse().unwrap());
        let token = GarrisonGrpcInterceptor::extract_token(&metadata)
            .unwrap_or_else(|e| panic!("混合大小写 scheme 应被接受: {header}, 实际: {e}"));
        assert_eq!(token, header.split_once(' ').unwrap().1);
    }
}

/// extract_token 拒绝超过 MAX_TOKEN_LEN 的超长 token(边界值恰好 MAX_TOKEN_LEN 应被接受)。
#[test]
fn test_extract_token_rejects_overlong_token() {
    let mut metadata = MetadataMap::new();
    let long_token = "a".repeat(super::MAX_TOKEN_LEN + 1);
    metadata.insert(
        "authorization",
        format!("Bearer {long_token}").parse().unwrap(),
    );
    let result = GarrisonGrpcInterceptor::extract_token(&metadata);
    assert!(result.is_err(), "超长 token 应被拒绝");
    assert_eq!(result.unwrap_err().code(), tonic::Code::Unauthenticated);

    let mut metadata = MetadataMap::new();
    let exact_token = "a".repeat(super::MAX_TOKEN_LEN);
    metadata.insert(
        "authorization",
        format!("Bearer {exact_token}").parse().unwrap(),
    );
    assert!(GarrisonGrpcInterceptor::extract_token(&metadata).is_ok());
}

/// extract_token 缺失 Authorization metadata 时返回 UNAUTHENTICATED。
#[test]
fn test_extract_token_missing_metadata() {
    let metadata = MetadataMap::new();
    let result = GarrisonGrpcInterceptor::extract_token(&metadata);
    assert!(result.is_err());
    let status = result.unwrap_err();
    assert_eq!(status.code(), tonic::Code::Unauthenticated);
    assert!(status.message().contains("missing Authorization"));
}

/// extract_token 在 Bearer 后 token 为空时返回 UNAUTHENTICATED。
#[test]
fn test_extract_token_empty_after_bearer() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "Bearer ".parse().unwrap());
    let result = GarrisonGrpcInterceptor::extract_token(&metadata);
    assert!(result.is_err());
    let status = result.unwrap_err();
    assert_eq!(status.code(), tonic::Code::Unauthenticated);
}

/// extract_token 拒绝裸 token(RFC 7235 严格校验,防 Basic/Digest 凭证误认为 Bearer)。
#[test]
fn test_extract_token_bare_token_rejected() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "raw-token-12345".parse().unwrap());
    let result = GarrisonGrpcInterceptor::extract_token(&metadata);
    assert!(result.is_err(), "裸 token 应被拒绝");
    let status = result.unwrap_err();
    assert_eq!(status.code(), tonic::Code::Unauthenticated);
    assert!(
        status.message().contains("Bearer"),
        "错误消息应提及 Bearer scheme"
    );
}

/// extract_token 在 Authorization 为空字符串时返回 UNAUTHENTICATED。
#[test]
fn test_extract_token_empty_value() {
    let mut metadata = MetadataMap::new();
    metadata.insert("authorization", "".parse().unwrap());
    let result = GarrisonGrpcInterceptor::extract_token(&metadata);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Unauthenticated);
}

#[test]
fn test_interceptor_call_with_valid_token() {
    let mut interceptor = GarrisonGrpcInterceptor::new();
    let mut request = tonic::Request::new(());
    request
        .metadata_mut()
        .insert("authorization", "Bearer valid-token".parse().unwrap());
    let result = interceptor.call(request);
    assert!(result.is_ok(), "valid token should pass: {:?}", result);
}

#[test]
fn test_interceptor_call_missing_metadata() {
    let mut interceptor = GarrisonGrpcInterceptor::new();
    let request = tonic::Request::new(());
    let result = interceptor.call(request);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Unauthenticated);
}

/// Interceptor::call() 把提取的 token 以 GarrisonGrpcToken 注入 request extensions,且 Debug 输出脱敏。
#[test]
fn test_interceptor_call_injects_token_into_extensions() {
    let mut interceptor = GarrisonGrpcInterceptor::new();
    let mut request = tonic::Request::new(());
    request
        .metadata_mut()
        .insert("authorization", "Bearer secret-token-abc".parse().unwrap());
    let request = interceptor.call(request).expect("合法 token 应放行");
    let injected = request
        .extensions()
        .get::<GarrisonGrpcToken>()
        .expect("token 应注入 request extensions");
    assert_eq!(injected.0, "secret-token-abc");
    let debug = format!("{:?}", injected);
    assert!(
        !debug.contains("secret-token-abc"),
        "Debug 不得泄露 token: {debug}"
    );
    assert!(debug.contains("[REDACTED]"));
}

/// 配置同步校验器后校验失败的 token 以 UNAUTHENTICATED 拒绝,不进入 handler。
#[test]
fn test_interceptor_with_validator_rejects_invalid_token() {
    struct RejectAll;
    impl GarrisonGrpcTokenValidator for RejectAll {
        fn validate(&self, _token: &str) -> Result<(), tonic::Status> {
            Err(tonic::Status::unauthenticated("invalid token"))
        }
    }
    let mut interceptor =
        GarrisonGrpcInterceptor::with_token_validator(std::sync::Arc::new(RejectAll));
    let mut request = tonic::Request::new(());
    request
        .metadata_mut()
        .insert("authorization", "Bearer some-token".parse().unwrap());
    let result = interceptor.call(request);
    assert!(result.is_err(), "校验器拒绝的 token 不应放行");
    assert_eq!(result.unwrap_err().code(), tonic::Code::Unauthenticated);
}

/// 配置同步校验器后合法 token 放行且 token 注入 extensions。
#[test]
fn test_interceptor_with_validator_accepts_valid_token() {
    struct AcceptAll;
    impl GarrisonGrpcTokenValidator for AcceptAll {
        fn validate(&self, _token: &str) -> Result<(), tonic::Status> {
            Ok(())
        }
    }
    let mut interceptor =
        GarrisonGrpcInterceptor::with_token_validator(std::sync::Arc::new(AcceptAll));
    let mut request = tonic::Request::new(());
    request
        .metadata_mut()
        .insert("authorization", "Bearer good-token".parse().unwrap());
    let request = interceptor.call(request).expect("校验通过的 token 应放行");
    assert!(request.extensions().get::<GarrisonGrpcToken>().is_some());
}

/// Clone trait(用于 tonic interceptor 复用)。
#[test]
fn test_interceptor_clone() {
    let i1 = GarrisonGrpcInterceptor::new();
    let _i2 = i1.clone();
}

/// Debug trait。
#[test]
fn test_interceptor_debug() {
    let interceptor = GarrisonGrpcInterceptor::new();
    let debug_str = format!("{:?}", interceptor);
    assert!(debug_str.contains("GarrisonGrpcInterceptor"));
}

// health_service() 健康检查服务测试

/// health_service() 成功返回 HealthServer,断言 NamedService::NAME 为标准健康检查服务名。
#[tokio::test]
async fn test_health_service_returns_server() {
    let server = super::health_service().await;
    fn assert_named_service<T: tonic::server::NamedService>(_: &T) -> &'static str {
        T::NAME
    }
    let name = assert_named_service(&server);
    assert_eq!(
        name, "grpc.health.v1.Health",
        "health_service 应返回标准 gRPC health 服务"
    );
}

/// health_service() 返回类型实现 tonic::server::NamedService(注册到 tonic Server 的前提)。
#[tokio::test]
async fn test_health_service_implements_named_service() {
    fn _assert_named_service<T: tonic::server::NamedService>(_: &T) {}
    let server = super::health_service().await;
    _assert_named_service(&server);
}

/// health_service() 返回的 NamedService 名称为标准 gRPC health check 服务名:`HealthServer` 对
/// `NamedService` 有 blanket impl,返回有效实例即表示 trait 已实现。
#[tokio::test]
async fn test_health_service_named_service_name() {
    let server = super::health_service().await;
    fn name_of<T: tonic::server::NamedService>(_: &T) -> &'static str {
        T::NAME
    }
    assert_eq!(name_of(&server), "grpc.health.v1.Health");
}

/// health_service() 多次调用返回独立实例(无全局状态泄漏)。
#[tokio::test]
async fn test_health_service_multiple_calls() {
    let _s1 = super::health_service().await;
    let _s2 = super::health_service().await;
}