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");
}
#[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);
}
}
#[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());
}
#[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"));
}
#[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);
}
#[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"
);
}
#[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);
}
#[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]"));
}
#[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);
}
#[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());
}
#[test]
fn test_interceptor_clone() {
let i1 = GarrisonGrpcInterceptor::new();
let _i2 = i1.clone();
}
#[test]
fn test_interceptor_debug() {
let interceptor = GarrisonGrpcInterceptor::new();
let debug_str = format!("{:?}", interceptor);
assert!(debug_str.contains("GarrisonGrpcInterceptor"));
}
#[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 服务"
);
}
#[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);
}
#[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");
}
#[tokio::test]
async fn test_health_service_multiple_calls() {
let _s1 = super::health_service().await;
let _s2 = super::health_service().await;
}