use crate::config::GarrisonConfig;
use crate::context::token_extract::{extract_token_from_request_parts, parse_cookie_value};
use crate::context::{GarrisonContext, GarrisonRequest, GarrisonResponse, GarrisonStorage};
use crate::error::{GarrisonError, GarrisonResult};
use axum::body::Body;
use axum::http::{HeaderMap, HeaderName, HeaderValue, Request, StatusCode};
use std::collections::HashMap;
pub struct AxumRequest<'a> {
request: &'a Request<Body>,
body_bytes: Vec<u8>,
}
impl<'a> AxumRequest<'a> {
pub fn new(request: &'a Request<Body>) -> Self {
Self::with_body(request, Vec::new())
}
pub fn with_body(request: &'a Request<Body>, body_bytes: Vec<u8>) -> Self {
Self {
request,
body_bytes,
}
}
}
impl<'a> GarrisonRequest for AxumRequest<'a> {
fn path(&self) -> GarrisonResult<String> {
Ok(self.request.uri().path().to_string())
}
fn method(&self) -> GarrisonResult<String> {
Ok(self.request.method().as_str().to_string())
}
fn header(&self, name: &str) -> GarrisonResult<Option<String>> {
let header_name: HeaderName = name.parse().map_err(|e| {
GarrisonError::Context(format!("ctx-invalid-header-name::{}::{}", name, e))
})?;
Ok(self
.request
.headers()
.get(header_name)
.and_then(|v| v.to_str().ok())
.map(|s| s.to_string()))
}
fn cookie(&self, name: &str) -> GarrisonResult<Option<String>> {
let cookie_header = self
.request
.headers()
.get(axum::http::header::COOKIE)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
Ok(parse_cookie_value(cookie_header, name))
}
fn get_token(&self, config: &GarrisonConfig) -> GarrisonResult<Option<String>> {
extract_token_from_request_parts(
config,
&self.body_bytes,
self.request.method().as_str(),
|name| self.header(name),
|name| self.cookie(name),
)
}
}
pub struct AxumResponse {
headers: HeaderMap,
status: StatusCode,
}
impl AxumResponse {
pub fn new() -> Self {
Self {
headers: HeaderMap::new(),
status: StatusCode::OK,
}
}
}
impl Default for AxumResponse {
fn default() -> Self {
Self::new()
}
}
impl AxumResponse {
pub fn to_response(self) -> axum::response::Response {
let mut response = axum::response::Response::new(Body::empty());
*response.status_mut() = self.status;
*response.headers_mut() = self.headers;
response
}
}
impl GarrisonResponse for AxumResponse {
fn set_status(&mut self, code: u16) -> GarrisonResult<()> {
self.status = StatusCode::from_u16(code).map_err(|e| {
GarrisonError::Context(format!("ctx-invalid-status-code::{}::{}", code, e))
})?;
Ok(())
}
fn set_header(&mut self, name: &str, value: &str) -> GarrisonResult<()> {
let header_name: HeaderName = name.parse().map_err(|e| {
GarrisonError::Context(format!("ctx-invalid-header-name::{}::{}", name, e))
})?;
let header_value = HeaderValue::from_str(value).map_err(|e| {
GarrisonError::Context(format!("ctx-invalid-header-value::{}::{}", value, e))
})?;
self.headers.insert(header_name, header_value);
Ok(())
}
}
pub struct AxumStorage {
map: HashMap<String, String>,
}
impl AxumStorage {
pub fn new() -> Self {
Self {
map: HashMap::new(),
}
}
}
impl Default for AxumStorage {
fn default() -> Self {
Self::new()
}
}
impl GarrisonStorage for AxumStorage {
fn set(&mut self, key: &str, value: &str) -> GarrisonResult<()> {
self.map.insert(key.to_string(), value.to_string());
Ok(())
}
fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
Ok(self.map.get(key).cloned())
}
fn delete(&mut self, key: &str) -> GarrisonResult<()> {
self.map.remove(key);
Ok(())
}
}
pub struct AxumContext<'a> {
request: &'a Request<Body>,
response: AxumResponse,
body_bytes: Vec<u8>,
}
impl<'a> AxumContext<'a> {
pub fn new(request: &'a Request<Body>) -> Self {
Self {
request,
response: AxumResponse::new(),
body_bytes: Vec::new(),
}
}
pub fn with_body(request: &'a Request<Body>, body_bytes: Vec<u8>) -> Self {
Self {
request,
response: AxumResponse::new(),
body_bytes,
}
}
pub fn raw_request(&self) -> &Request<Body> {
self.request
}
pub fn raw_response(&self) -> &AxumResponse {
&self.response
}
pub fn raw_response_mut(&mut self) -> &mut AxumResponse {
&mut self.response
}
pub fn into_response(self) -> axum::response::Response {
self.response.to_response()
}
}
impl<'a> GarrisonContext for AxumContext<'a> {
fn request(&self) -> GarrisonResult<Box<dyn GarrisonRequest>> {
Ok(Box::new(AxumRequestWrapper::with_body(
self.request,
self.body_bytes.clone(),
)))
}
}
struct AxumRequestWrapper {
headers: HeaderMap,
method: String,
uri: String,
body_bytes: Vec<u8>,
}
impl AxumRequestWrapper {
fn with_body(req: &Request<Body>, body_bytes: Vec<u8>) -> Self {
Self {
headers: req.headers().clone(),
method: req.method().as_str().to_string(),
uri: req.uri().to_string(),
body_bytes,
}
}
}
impl GarrisonRequest for AxumRequestWrapper {
fn path(&self) -> GarrisonResult<String> {
Ok(self.uri.split('?').next().unwrap_or(&self.uri).to_string())
}
fn method(&self) -> GarrisonResult<String> {
Ok(self.method.clone())
}
fn header(&self, name: &str) -> GarrisonResult<Option<String>> {
let header_name: HeaderName = name.parse().map_err(|e| {
GarrisonError::Context(format!("ctx-invalid-header-name::{}::{}", name, e))
})?;
Ok(self
.headers
.get(header_name)
.and_then(|v| v.to_str().ok())
.map(|s| s.to_string()))
}
fn cookie(&self, name: &str) -> GarrisonResult<Option<String>> {
let cookie_header = self
.headers
.get(axum::http::header::COOKIE)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
Ok(parse_cookie_value(cookie_header, name))
}
fn get_token(&self, config: &GarrisonConfig) -> GarrisonResult<Option<String>> {
extract_token_from_request_parts(
config,
&self.body_bytes,
&self.method,
|name| self.header(name),
|name| self.cookie(name),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use axum::http::Request;
fn make_request(uri: &str, method: &str, headers: &[(&str, &str)]) -> Request<Body> {
let mut builder = Request::builder().method(method).uri(uri);
for (name, value) in headers {
builder = builder.header(*name, *value);
}
builder.body(Body::empty()).unwrap()
}
fn make_request_with_body(
uri: &str,
method: &str,
headers: &[(&str, &str)],
body: &str,
) -> Request<Body> {
let mut builder = Request::builder().method(method).uri(uri);
for (name, value) in headers {
builder = builder.header(*name, *value);
}
builder.body(Body::from(body.to_string())).unwrap()
}
#[test]
fn axum_request_path() {
let req = make_request("/api/users?id=1", "GET", &[]);
let axum_req = AxumRequest::new(&req);
assert_eq!(axum_req.path().unwrap(), "/api/users");
}
#[test]
fn axum_request_method() {
let req = make_request("/", "POST", &[]);
let axum_req = AxumRequest::new(&req);
assert_eq!(axum_req.method().unwrap(), "POST");
}
#[test]
fn axum_request_header() {
let req = make_request("/", "GET", &[("X-Token", "abc123")]);
let axum_req = AxumRequest::new(&req);
assert_eq!(
axum_req.header("X-Token").unwrap(),
Some("abc123".to_string())
);
assert_eq!(axum_req.header("Not-Exist").unwrap(), None);
}
#[test]
fn axum_request_cookie() {
let req = make_request(
"/",
"GET",
&[("Cookie", "garrison_token=tok123; other=val")],
);
let axum_req = AxumRequest::new(&req);
assert_eq!(
axum_req.cookie("garrison_token").unwrap(),
Some("tok123".to_string())
);
assert_eq!(axum_req.cookie("other").unwrap(), Some("val".to_string()));
assert_eq!(axum_req.cookie("missing").unwrap(), None);
}
#[test]
fn get_token_from_bearer_header() {
let req = make_request("/", "GET", &[("Authorization", "Bearer my_token_123")]);
let axum_req = AxumRequest::new(&req);
let config = GarrisonConfig::default_config();
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, Some("my_token_123".to_string()));
}
#[test]
fn bearer_prefix_case_insensitive() {
let config = GarrisonConfig::default_config();
for prefix in &["Bearer", "bearer", "BEARER", "BeArEr"] {
let auth_value = format!("{} tok_{}", prefix, prefix);
let req = make_request("/", "GET", &[("Authorization", auth_value.as_str())]);
let axum_req = AxumRequest::new(&req);
let token = axum_req.get_token(&config).unwrap();
assert_eq!(
token,
Some(format!("tok_{}", prefix)),
"前缀 '{}' 应能提取 token(大小写不敏感)",
prefix
);
}
}
#[test]
fn get_token_from_custom_header() {
let req = make_request("/", "GET", &[("garrison_token", "header_token_456")]);
let axum_req = AxumRequest::new(&req);
let config = GarrisonConfig::default_config();
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, Some("header_token_456".to_string()));
}
#[test]
fn get_token_from_cookie() {
let config = GarrisonConfig::default_config();
let cookie_value = format!(
"{}=cookie_token_789",
crate::context::token_cookie_name(&config)
);
let req = make_request("/", "GET", &[("Cookie", cookie_value.as_str())]);
let axum_req = AxumRequest::new(&req);
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, Some("cookie_token_789".to_string()));
}
#[test]
fn get_token_header_priority_over_cookie() {
let config = GarrisonConfig::default_config();
let cookie_value = format!(
"{}=cookie_token",
crate::context::token_cookie_name(&config)
);
let req = make_request(
"/",
"GET",
&[
("Authorization", "Bearer header_token"),
("Cookie", cookie_value.as_str()),
],
);
let axum_req = AxumRequest::new(&req);
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, Some("header_token".to_string()));
}
#[test]
fn get_token_returns_none_when_missing() {
let req = make_request("/", "GET", &[]);
let axum_req = AxumRequest::new(&req);
let config = GarrisonConfig::default_config();
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, None);
}
#[test]
fn get_token_skips_header_when_disabled() {
let req = make_request("/", "GET", &[("Authorization", "Bearer header_token")]);
let axum_req = AxumRequest::new(&req);
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
let token = axum_req.get_token(&config).unwrap();
assert_eq!(token, None);
}
#[test]
fn response_set_status() {
let mut resp = AxumResponse::new();
resp.set_status(401).unwrap();
assert_eq!(resp.status, StatusCode::UNAUTHORIZED);
}
#[test]
fn response_set_header() {
let mut resp = AxumResponse::new();
resp.set_header("Authorization", "my_token").unwrap();
assert_eq!(
resp.headers
.get("Authorization")
.and_then(|v| v.to_str().ok()),
Some("my_token")
);
}
#[test]
fn response_set_cookie() {
let mut resp = AxumResponse::new();
resp.set_cookie("garrison_token", "cookie_value").unwrap();
let set_cookie = resp
.headers
.get("Set-Cookie")
.and_then(|v| v.to_str().ok())
.unwrap();
assert!(set_cookie.contains("garrison_token=cookie_value"));
assert!(set_cookie.contains("HttpOnly"));
assert!(set_cookie.contains("Secure"));
assert!(set_cookie.contains("SameSite=Lax"));
assert!(set_cookie.contains("Path=/"));
}
#[test]
fn response_set_cookie_rejects_injection() {
let mut resp = AxumResponse::new();
let result = resp.set_cookie("token", "abc; Domain=evil.com");
assert!(
matches!(result, Err(GarrisonError::Context(_))),
"value 含 ';' 应返回错误,实际: {:?}",
result.map(|_| ())
);
let result = resp.set_cookie("to;ken", "v");
assert!(matches!(result, Err(GarrisonError::Context(_))));
let result = resp.set_cookie("token", "bad\nvalue");
assert!(matches!(result, Err(GarrisonError::Context(_))));
let result = resp.set_cookie("token", "a b");
assert!(matches!(result, Err(GarrisonError::Context(_))));
let result = resp.set_cookie("token", "a,b");
assert!(matches!(result, Err(GarrisonError::Context(_))));
assert!(
resp.headers.get("Set-Cookie").is_none(),
"校验失败时不应产生 Set-Cookie 头"
);
let mut resp2 = AxumResponse::new();
assert!(resp2.set_cookie("token", "abc123_def-.~").is_ok());
}
#[test]
fn response_set_cookie_with_config_dev() {
let mut resp = AxumResponse::new();
let mut config = GarrisonConfig::default_config();
config.cookie_secure = false;
config.cookie_same_site = "Strict".to_string();
resp.set_cookie_with_config("token", "v", &config).unwrap();
let set_cookie = resp
.headers
.get("Set-Cookie")
.and_then(|v| v.to_str().ok())
.unwrap();
assert!(set_cookie.contains("HttpOnly"));
assert!(!set_cookie.contains("Secure"));
assert!(set_cookie.contains("SameSite=Strict"));
}
#[test]
fn response_set_cookie_none_insecure_downgrades_to_lax() {
let mut resp = AxumResponse::new();
let mut config = GarrisonConfig::default_config();
config.cookie_secure = false;
config.cookie_same_site = "None".to_string();
resp.set_cookie_with_config("token", "v", &config).unwrap();
let set_cookie = resp
.headers
.get("Set-Cookie")
.and_then(|v| v.to_str().ok())
.unwrap();
assert!(
set_cookie.contains("SameSite=Lax"),
"应降级为 SameSite=Lax,实际: {}",
set_cookie
);
assert!(
!set_cookie.contains("SameSite=None"),
"不得输出 SameSite=None,实际: {}",
set_cookie
);
assert!(!set_cookie.contains("Secure"), "实际: {}", set_cookie);
assert!(
!set_cookie.contains("__Host-") && !set_cookie.contains("__Secure-"),
"http 降级无前缀,实际: {}",
set_cookie
);
}
#[test]
fn response_to_axum_response() {
let mut resp = AxumResponse::new();
resp.set_status(403).unwrap();
resp.set_header("X-Custom", "test").unwrap();
let axum_resp = resp.to_response();
assert_eq!(axum_resp.status(), StatusCode::FORBIDDEN);
assert_eq!(
axum_resp
.headers()
.get("X-Custom")
.and_then(|v| v.to_str().ok()),
Some("test")
);
}
#[test]
fn response_invalid_status_errors() {
let mut resp = AxumResponse::new();
assert!(resp.set_status(200).is_ok());
assert!(resp.set_status(500).is_ok());
}
#[test]
fn response_invalid_header_name_errors() {
let mut resp = AxumResponse::new();
let result = resp.set_header("invalid header", "value");
assert!(
matches!(result, Err(GarrisonError::Context(_))),
"无效 header name 应返回 Context 错误,实际: {:?}",
result
);
}
#[test]
fn storage_set_get() {
let mut storage = AxumStorage::new();
storage.set("trace_id", "abc-123").unwrap();
assert_eq!(
storage.get("trace_id").unwrap(),
Some("abc-123".to_string())
);
}
#[test]
fn storage_delete() {
let mut storage = AxumStorage::new();
storage.set("key1", "value1").unwrap();
storage.delete("key1").unwrap();
assert_eq!(storage.get("key1").unwrap(), None);
}
#[test]
fn storage_request_isolation() {
let mut storage_a = AxumStorage::new();
storage_a.set("trace_id", "A").unwrap();
let mut storage_b = AxumStorage::new();
storage_b.set("trace_id", "B").unwrap();
assert_eq!(storage_a.get("trace_id").unwrap(), Some("A".to_string()));
assert_eq!(storage_b.get("trace_id").unwrap(), Some("B".to_string()));
}
#[test]
fn storage_missing_key_returns_none() {
let storage = AxumStorage::new();
assert_eq!(storage.get("missing").unwrap(), None);
}
#[test]
fn context_creation() {
let req = make_request("/api/test", "GET", &[("X-Test", "value")]);
let ctx = AxumContext::new(&req);
assert_eq!(ctx.raw_request().uri().path(), "/api/test");
}
#[test]
fn context_trait_impl() {
let req = make_request("/", "GET", &[("Authorization", "Bearer abc")]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
let config = GarrisonConfig::default_config();
let token = request.get_token(&config).unwrap();
assert_eq!(token, Some("abc".to_string()));
let mut ctx = ctx;
ctx.raw_response_mut().set_status(403).unwrap();
ctx.raw_response_mut().set_header("X-Trace", "v").unwrap();
let resp = ctx.into_response();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
}
#[test]
fn axum_request_header_invalid_name_errors() {
let _locale_guard = crate::i18n::set_locale(crate::i18n::GarrisonLocale::Zh);
let req = make_request("/", "GET", &[]);
let axum_req = AxumRequest::new(&req);
let result = axum_req.header("invalid header");
assert!(result.is_err());
let err = result.unwrap_err();
assert!(matches!(err, GarrisonError::Context(_)));
assert!(err.to_string().contains("非法 header 名称"));
}
#[test]
fn axum_request_cookie_empty_header_returns_none() {
let req = make_request("/", "GET", &[]);
let axum_req = AxumRequest::new(&req);
assert_eq!(axum_req.cookie("any").unwrap(), None);
}
#[test]
fn axum_request_cookie_skips_pair_without_equals() {
let req = make_request("/", "GET", &[("Cookie", "invalidpair; valid=val")]);
let axum_req = AxumRequest::new(&req);
assert_eq!(axum_req.cookie("valid").unwrap(), Some("val".to_string()));
assert_eq!(axum_req.cookie("invalidpair").unwrap(), None);
}
#[test]
fn axum_response_set_status_invalid_code_errors() {
let _locale_guard = crate::i18n::set_locale(crate::i18n::GarrisonLocale::Zh);
let mut resp = AxumResponse::new();
let result = resp.set_status(1000);
assert!(result.is_err());
let err = result.unwrap_err();
assert!(matches!(err, GarrisonError::Context(_)));
assert!(err.to_string().contains("非法状态码"));
}
#[test]
fn axum_response_set_header_invalid_value_errors() {
let _locale_guard = crate::i18n::set_locale(crate::i18n::GarrisonLocale::Zh);
let mut resp = AxumResponse::new();
let result = resp.set_header("X-Test", "bad\0value");
assert!(result.is_err());
let err = result.unwrap_err();
assert!(matches!(err, GarrisonError::Context(_)));
assert!(err.to_string().contains("非法 header 值"));
}
#[test]
fn axum_response_default_impl() {
let resp = AxumResponse::default();
assert_eq!(resp.status, StatusCode::OK);
assert!(resp.headers.is_empty());
}
#[test]
fn axum_storage_default_impl() {
let storage = AxumStorage::default();
assert_eq!(storage.get("any").unwrap(), None);
}
#[test]
fn axum_context_wrapper_path_strips_query() {
let req = make_request("/api/v1/users?page=2&size=10", "GET", &[]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(request.path().unwrap(), "/api/v1/users");
}
#[test]
fn axum_context_wrapper_method() {
let req = make_request("/", "PUT", &[]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(request.method().unwrap(), "PUT");
}
#[test]
fn axum_context_wrapper_header() {
let req = make_request("/", "GET", &[("X-Custom", "hello"), ("X-Other", "world")]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(
request.header("X-Custom").unwrap(),
Some("hello".to_string())
);
assert_eq!(
request.header("X-Other").unwrap(),
Some("world".to_string())
);
assert_eq!(request.header("Missing").unwrap(), None);
}
#[test]
fn axum_context_wrapper_header_invalid_name_errors() {
let _locale_guard = crate::i18n::set_locale(crate::i18n::GarrisonLocale::Zh);
let req = make_request("/", "GET", &[]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
let result = request.header("bad name");
assert!(result.is_err());
let err = result.unwrap_err();
assert!(matches!(err, GarrisonError::Context(_)));
assert!(err.to_string().contains("非法 header 名称"));
}
#[test]
fn axum_context_wrapper_cookie_no_header_returns_none() {
let req = make_request("/", "GET", &[]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(request.cookie("any").unwrap(), None);
}
#[test]
fn axum_context_wrapper_cookie_found() {
let req = make_request("/", "GET", &[("Cookie", "session=abc; user=xyz")]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(request.cookie("session").unwrap(), Some("abc".to_string()));
assert_eq!(request.cookie("user").unwrap(), Some("xyz".to_string()));
assert_eq!(request.cookie("missing").unwrap(), None);
}
#[test]
fn axum_context_wrapper_cookie_skips_pair_without_equals() {
let req = make_request("/", "GET", &[("Cookie", "invalidpair; valid=val")]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
assert_eq!(request.cookie("valid").unwrap(), Some("val".to_string()));
assert_eq!(request.cookie("invalidpair").unwrap(), None);
}
#[test]
fn axum_context_wrapper_get_token_from_cookie() {
let mut config = GarrisonConfig::default_config();
let cookie_value = format!("{}=cookie_tok", crate::context::token_cookie_name(&config));
let req = make_request("/", "GET", &[("Cookie", cookie_value.as_str())]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
config.is_read_header = false;
config.is_read_cookie = true;
let token = request.get_token(&config).unwrap();
assert_eq!(token, Some("cookie_tok".to_string()));
}
#[test]
fn axum_context_wrapper_get_token_returns_none() {
let req = make_request("/", "GET", &[]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
let config = GarrisonConfig::default_config();
let token = request.get_token(&config).unwrap();
assert_eq!(token, None);
}
#[test]
fn axum_context_wrapper_bearer_case_insensitive() {
let config = GarrisonConfig::default_config();
for prefix in ["Bearer", "bearer", "BEARER", "BeArEr"] {
let header_value = format!("{} my_token_123", prefix);
let req = make_request("/", "GET", &[("Authorization", &header_value)]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
let token = request.get_token(&config).unwrap();
assert_eq!(
token,
Some("my_token_123".to_string()),
"prefix '{}' should extract token (RFC 7235 case-insensitive)",
prefix
);
}
}
#[test]
fn axum_context_raw_response_mut_writable() {
let req = make_request("/", "GET", &[]);
let mut ctx = AxumContext::new(&req);
ctx.raw_response_mut().set_status(404).unwrap();
ctx.raw_response_mut()
.set_header("X-Trace", "trace-123")
.unwrap();
assert_eq!(ctx.raw_response().status, StatusCode::NOT_FOUND);
let resp = ctx.into_response();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_eq!(
resp.headers().get("X-Trace").and_then(|v| v.to_str().ok()),
Some("trace-123")
);
}
#[test]
fn axum_context_into_response_default() {
let req = make_request("/", "GET", &[]);
let ctx = AxumContext::new(&req);
let response = ctx.into_response();
assert_eq!(response.status(), StatusCode::OK);
}
#[test]
fn extract_token_from_body_when_is_read_body_true() {
let body_str = r#"{"token": "abc123"}"#;
let req = make_request_with_body(
"/",
"POST",
&[("Content-Type", "application/json")],
body_str,
);
let ctx = AxumContext::with_body(&req, body_str.as_bytes().to_vec());
let request = ctx.request().unwrap();
let mut config = GarrisonConfig::default_config();
config.is_read_body = true;
config.token_name = "token".to_string();
let token = request.get_token(&config).unwrap();
assert_eq!(
token,
Some("abc123".to_string()),
"is_read_body=true 且 body 含 token 字段时应提取到 token"
);
}
#[test]
fn extract_token_fallback_to_header_when_body_empty() {
let body_str = r#"{"other": "value"}"#;
let req = make_request_with_body(
"/",
"POST",
&[
("Content-Type", "application/json"),
("Authorization", "Bearer header_tok_456"),
],
body_str,
);
let ctx = AxumContext::with_body(&req, body_str.as_bytes().to_vec());
let request = ctx.request().unwrap();
let mut config = GarrisonConfig::default_config();
config.is_read_body = true;
config.token_name = "token".to_string();
let token = request.get_token(&config).unwrap();
assert_eq!(
token,
Some("header_tok_456".to_string()),
"body 无 token 字段时应回退到 header 读取"
);
}
#[test]
fn c7_axum_request_get_method_skips_body_token() {
let body_str = r#"{"garrison_token":"body_token_should_be_skipped"}"#;
let req = make_request_with_body(
"/",
"GET",
&[("Content-Type", "application/json")],
body_str,
);
let axum_req = AxumRequest::with_body(&req, body_str.as_bytes().to_vec());
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
config.is_read_body = true;
let token = axum_req.get_token(&config).unwrap();
assert_eq!(
token, None,
"C7: GET 方法不应从 body 提取 token(防 body 注入攻击)"
);
}
#[test]
fn c7_axum_request_post_method_allows_body_token() {
let body_str = r#"{"garrison_token":"body_token_ok"}"#;
let req = make_request_with_body(
"/",
"POST",
&[("Content-Type", "application/json")],
body_str,
);
let axum_req = AxumRequest::with_body(&req, body_str.as_bytes().to_vec());
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
config.is_read_body = true;
let token = axum_req.get_token(&config).unwrap();
assert_eq!(
token,
Some("body_token_ok".to_string()),
"C7: POST 方法应允许从 body 提取 token"
);
}
#[test]
fn c7_axum_context_get_method_skips_body_token_via_wrapper() {
let body_str = r#"{"garrison_token":"wrapper_skipped"}"#;
let req = make_request_with_body(
"/",
"GET",
&[("Content-Type", "application/json")],
body_str,
);
let ctx = AxumContext::with_body(&req, body_str.as_bytes().to_vec());
let request = ctx.request().unwrap();
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
config.is_read_body = true;
let token = request.get_token(&config).unwrap();
assert_eq!(
token, None,
"C7: 通过 AxumContext 的 GET 方法不应从 body 提取 token"
);
}
#[test]
fn c7_axum_context_put_patch_methods_allow_body_token_via_wrapper() {
for method in &["PUT", "PATCH"] {
let body_str = format!(r#"{{"garrison_token":"tok_{}"}}"#, method);
let req = make_request_with_body(
"/",
method,
&[("Content-Type", "application/json")],
&body_str,
);
let ctx = AxumContext::with_body(&req, body_str.as_bytes().to_vec());
let request = ctx.request().unwrap();
let mut config = GarrisonConfig::default_config();
config.is_read_header = false;
config.is_read_cookie = false;
config.is_read_body = true;
let token = request.get_token(&config).unwrap();
assert_eq!(
token,
Some(format!("tok_{}", method)),
"C7: {} 方法应允许从 body 提取 token",
method
);
}
}
}