#![cfg(feature = "token")]
use crate::action::{ActionContext, ActionMeta, ApiResponse, DynAction, Request, RequestId};
use crate::error::BaseError;
use crate::router::middleware::{
AuthorizationPolicy, Middleware, Next, PermissionGroup, RequestIdMiddleware,
};
use crate::tools::{Tools, ToolsBuilder};
use async_trait::async_trait;
use serde_json::json;
use std::sync::Arc;
struct MockAction;
#[async_trait]
impl DynAction for MockAction {
async fn dispatch(&self, _ctx: ActionContext) -> Result<ApiResponse, BaseError> {
unreachable!("request_id 测试不应触达 action 派发")
}
fn meta(&self) -> &'static ActionMeta {
unreachable!("request_id 测试不应访问 meta")
}
}
struct CaptureMiddleware {
captured: Arc<std::sync::Mutex<Option<RequestId>>>,
}
#[async_trait]
impl Middleware for CaptureMiddleware {
async fn handle(&self, ctx: ActionContext, _next: Next<'_>) -> Result<ApiResponse, BaseError> {
*self.captured.lock().unwrap() = Some(ctx.request_id);
Ok(ApiResponse::success_value(json!(null), "ok"))
}
}
fn test_tools() -> Arc<Tools> {
let tm = crate::token::TokenManager::new_symmetric(
"test_secret_for_request_id_testx",
jsonwebtoken::Algorithm::HS256,
"test_iss".into(),
"test_aud".into(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功");
Arc::new(
ToolsBuilder::new()
.token(tm)
.build()
.expect("测试 Tools 应构建成功"),
)
}
async fn run_test(request: Request, default_rid: RequestId) -> Option<RequestId> {
let ctx = ActionContext::new(request, test_tools()).with_request_id(default_rid);
let captured = Arc::new(std::sync::Mutex::new(None));
let mw: Arc<dyn Middleware> = Arc::new(CaptureMiddleware {
captured: captured.clone(),
});
let remaining = [mw];
let policy = AuthorizationPolicy::new(false, Vec::<PermissionGroup>::new());
let next = Next {
remaining: &remaining,
action: Arc::new(MockAction),
policy: &policy,
};
RequestIdMiddleware
.handle(ctx, next)
.await
.expect("RequestIdMiddleware 不应返回错误");
let result = captured.lock().unwrap().take();
result
}
#[tokio::test]
async fn test_request_id_middleware_propagates_header() {
let rid = RequestId::from_u128(0xdead_beef);
let request = Request::new(json!({})).header("X-Request-Id", rid.to_string());
let captured = run_test(request, RequestId::from_u128(0)).await;
assert_eq!(captured, Some(rid));
}
#[tokio::test]
async fn test_request_id_middleware_lowercase_tolerant() {
let rid = RequestId::from_u128(0xdead_beef);
let request = Request::new(json!({})).header("x-request-id", rid.to_string());
let captured = run_test(request, RequestId::from_u128(0)).await;
assert_eq!(captured, Some(rid));
}
#[tokio::test]
async fn test_request_id_middleware_rejects_zero_header() {
let default_rid = RequestId::from_u128(0xcafe_babe_0000_0000_0000_0000_0000_0001);
let request =
Request::new(json!({})).header("X-Request-Id", "00000000000000000000000000000000");
let captured = run_test(request, default_rid).await;
assert_eq!(captured, Some(default_rid));
}
#[tokio::test]
async fn test_request_id_middleware_missing_header_fallback() {
let default_rid = RequestId::from_u128(0xcafe_babe_0000_0000_0000_0000_0000_0001);
let request = Request::new(json!({}));
let captured = run_test(request, default_rid).await;
assert_eq!(captured, Some(default_rid));
}