use crate::config::GarrisonConfig;
use crate::context::token_extract::{is_body_token_allowed_method, strip_bearer_prefix};
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!("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("");
if cookie_header.is_empty() {
return Ok(None);
}
for cookie in cookie_header.split(';') {
let cookie = cookie.trim();
if let Some(eq_pos) = cookie.find('=') {
let (k, v) = cookie.split_at(eq_pos);
if k == name {
return Ok(Some(v[1..].to_string())); }
}
}
Ok(None)
}
fn get_token(&self, config: &GarrisonConfig) -> GarrisonResult<Option<String>> {
if config.is_read_header {
if let Some(auth) = self.header("Authorization")? {
if let Some(token) = strip_bearer_prefix(&auth) {
return Ok(Some(token.to_string()));
}
}
if let Some(token) = self.header(&config.token_name)? {
return Ok(Some(token));
}
}
if config.is_read_cookie {
if let Some(token) = self.cookie(&config.token_name)? {
return Ok(Some(token));
}
}
if config.is_read_body {
let method = self.request.method().as_str();
if !is_body_token_allowed_method(method) {
tracing::warn!(
method = method,
"C7: HTTP 方法不允许从 body 提取 token,已跳过 body 读取"
);
return Ok(None);
}
if let Some(token) = extract_token_from_json_body(
&self.body_bytes,
self.request.headers(),
&config.token_name,
)? {
return Ok(Some(token));
}
}
Ok(None)
}
}
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!("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!("invalid header name '{}': {}", name, e))
})?;
let header_value = HeaderValue::from_str(value).map_err(|e| {
GarrisonError::Context(format!("invalid header value '{}': {}", value, e))
})?;
self.headers.insert(header_name, header_value);
Ok(())
}
fn set_cookie(&mut self, name: &str, value: &str) -> GarrisonResult<()> {
let cookie_value = format!("{}={}; HttpOnly; Secure; SameSite=Lax; Path=/", name, value);
self.set_header("Set-Cookie", &cookie_value)
}
fn set_cookie_with_config(
&mut self,
name: &str,
value: &str,
config: &crate::config::GarrisonConfig,
) -> GarrisonResult<()> {
let secure_flag = if config.cookie_secure { "Secure; " } else { "" };
let cookie_value = format!(
"{}={}; HttpOnly; {}SameSite={}; Path=/",
name, value, secure_flag, config.cookie_same_site,
);
self.set_header("Set-Cookie", &cookie_value)
}
}
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!("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("");
if cookie_header.is_empty() {
return Ok(None);
}
for cookie in cookie_header.split(';') {
let cookie = cookie.trim();
if let Some(eq_pos) = cookie.find('=') {
let (k, v) = cookie.split_at(eq_pos);
if k == name {
return Ok(Some(v[1..].to_string()));
}
}
}
Ok(None)
}
fn get_token(&self, config: &GarrisonConfig) -> GarrisonResult<Option<String>> {
if config.is_read_header {
if let Some(auth) = self.header("Authorization")? {
if let Some(token) = strip_bearer_prefix(&auth) {
return Ok(Some(token.to_string()));
}
}
if let Some(token) = self.header(&config.token_name)? {
return Ok(Some(token));
}
}
if config.is_read_cookie {
if let Some(token) = self.cookie(&config.token_name)? {
return Ok(Some(token));
}
}
if config.is_read_body {
let method = self.method.as_str();
if !is_body_token_allowed_method(method) {
tracing::warn!(
method = method,
"C7: HTTP 方法不允许从 body 提取 token,已跳过 body 读取"
);
return Ok(None);
}
if let Some(token) =
extract_token_from_json_body(&self.body_bytes, &self.headers, &config.token_name)?
{
return Ok(Some(token));
}
}
Ok(None)
}
}
fn extract_token_from_json_body(
body_bytes: &[u8],
headers: &HeaderMap,
token_name: &str,
) -> GarrisonResult<Option<String>> {
if body_bytes.is_empty() {
return Ok(None);
}
let content_type = headers
.get(axum::http::header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok())
.unwrap_or("");
if !content_type.contains("application/json") {
return Ok(None);
}
let json: serde_json::Value = match serde_json::from_slice(body_bytes) {
Ok(v) => v,
Err(_) => return Ok(None),
};
if let Some(token) = json.get(token_name).and_then(|v| v.as_str()) {
return Ok(Some(token.to_string()));
}
Ok(None)
}
#[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 req = make_request("/", "GET", &[("Cookie", "garrison_token=cookie_token_789")]);
let axum_req = AxumRequest::new(&req);
let config = GarrisonConfig::default_config();
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 req = make_request(
"/",
"GET",
&[
("Authorization", "Bearer header_token"),
("Cookie", "garrison_token=cookie_token"),
],
);
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".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_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_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!(result.is_err());
}
#[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 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("invalid header name"));
}
#[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 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("invalid status code"));
}
#[test]
fn axum_response_set_header_invalid_value_errors() {
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("invalid header value"));
}
#[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 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("invalid header name"));
}
#[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 req = make_request("/", "GET", &[("Cookie", "garrison_token=cookie_tok")]);
let ctx = AxumContext::new(&req);
let request = ctx.request().unwrap();
let mut config = GarrisonConfig::default_config();
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
);
}
}
}