#![cfg(feature = "auth-server-sdforge")]
#![allow(unexpected_cfgs)]
#![allow(dead_code)]
use crate::backend::types::{
ApiResponse, CheckApiKeyRequest, CheckLoginRequest, CheckPermissionRequest, CheckRoleRequest,
LoginRequest, LogoutRequest, RenewToEquivalentRequest,
};
use crate::backend::AuthBackend;
use crate::error::GarrisonError;
use sdforge::forge;
use sdforge::prelude::ApiError;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use super::to_api_response;
#[derive(Debug, Clone, Serialize, Deserialize)]
struct GetSessionRequest {
pub token: String,
#[serde(default)]
pub caller_login_id: String,
#[serde(default)]
pub caller_token: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct GetTokenInfoRequest {
pub token: String,
#[serde(default)]
pub caller_login_id: String,
#[serde(default)]
pub caller_token: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SwitchToRequest {
pub token: String,
pub target_login_id: String,
#[serde(default)]
pub caller_login_id: String,
#[serde(default)]
pub caller_token: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct KickoutRequest {
pub login_id: String,
#[serde(default)]
pub caller_login_id: String,
#[serde(default)]
pub caller_token: Option<String>,
}
async fn can_view_pii(
backend: &Arc<dyn AuthBackend>,
caller_login_id: &str,
session_login_id: &str,
caller_token: &Option<String>,
) -> bool {
if !caller_login_id.is_empty() && caller_login_id == session_login_id {
return true;
}
match caller_token {
Some(t) if !t.is_empty() => backend.check_permission(t, "admin:sessions").await.is_ok(),
_ => false,
}
}
async fn can_switch_to(
backend: &Arc<dyn AuthBackend>,
caller_login_id: &str,
session_login_id: &str,
caller_token: &Option<String>,
) -> bool {
if !caller_login_id.is_empty() && caller_login_id == session_login_id {
return true;
}
match caller_token {
Some(t) if !t.is_empty() => backend.check_permission(t, "admin:sessions").await.is_ok(),
_ => false,
}
}
async fn can_kickout(
backend: &Arc<dyn AuthBackend>,
caller_login_id: &str,
target_login_id: &str,
caller_token: &Option<String>,
) -> bool {
if !caller_login_id.is_empty() && caller_login_id == target_login_id {
return true;
}
match caller_token {
Some(t) if !t.is_empty() => backend.check_permission(t, "admin:sessions").await.is_ok(),
_ => false,
}
}
#[forge(
name = "auth_login",
version = "v1",
path = "/auth/login",
method = "POST",
tool_name = "auth_login",
description = "用户登录,返回 token"
)]
async fn login(
#[state] backend: Arc<dyn AuthBackend>,
req: LoginRequest,
) -> Result<ApiResponse<String>, ApiError> {
let result = backend.login(&req.login_id, &req.params).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_logout",
version = "v1",
path = "/auth/logout",
method = "POST",
tool_name = "auth_logout",
description = "登出指定 token"
)]
async fn logout(
#[state] backend: Arc<dyn AuthBackend>,
req: LogoutRequest,
) -> Result<ApiResponse<()>, ApiError> {
let result = backend.logout(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_refresh",
version = "v1",
path = "/auth/refresh",
method = "POST",
tool_name = "auth_refresh",
description = "刷新 token"
)]
async fn refresh(
#[state] backend: Arc<dyn AuthBackend>,
req: RenewToEquivalentRequest,
) -> Result<ApiResponse<String>, ApiError> {
let result = backend.renew_to_equivalent(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_login",
version = "v1",
path = "/auth/check-login",
method = "POST",
tool_name = "auth_check_login",
description = "校验登录状态"
)]
async fn check_login(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckLoginRequest,
) -> Result<ApiResponse<bool>, ApiError> {
let result = backend.check_login(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_permission",
version = "v1",
path = "/auth/check-permission",
method = "POST",
tool_name = "auth_check_permission",
description = "校验权限"
)]
async fn check_permission(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckPermissionRequest,
) -> Result<ApiResponse<()>, ApiError> {
let result = backend.check_permission(&req.token, &req.permission).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_role",
version = "v1",
path = "/auth/check-role",
method = "POST",
tool_name = "auth_check_role",
description = "校验角色"
)]
async fn check_role(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckRoleRequest,
) -> Result<ApiResponse<()>, ApiError> {
let result = backend.check_role(&req.token, &req.role).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_safe",
version = "v1",
path = "/auth/check-safe",
method = "POST",
tool_name = "auth_check_safe",
description = "校验二级认证"
)]
async fn check_safe(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckLoginRequest,
) -> Result<ApiResponse<bool>, ApiError> {
let result = backend.check_safe(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_disable",
version = "v1",
path = "/auth/check-disable",
method = "POST",
tool_name = "auth_check_disable",
description = "校验封禁状态"
)]
async fn check_disable(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckLoginRequest,
) -> Result<ApiResponse<bool>, ApiError> {
let result = backend.check_disable(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_check_api_key",
version = "v1",
path = "/auth/check-api-key",
method = "POST",
tool_name = "auth_check_api_key",
description = "校验 API Key"
)]
async fn check_api_key(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckApiKeyRequest,
) -> Result<ApiResponse<()>, ApiError> {
let result = backend.check_api_key(&req.api_key, &req.namespace).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_get_token_info",
version = "v1",
path = "/auth/get-token-info",
method = "POST",
tool_name = "auth_get_token_info",
description = "获取 token 信息"
)]
async fn get_token_info(
#[state] backend: Arc<dyn AuthBackend>,
req: GetTokenInfoRequest,
) -> Result<ApiResponse<crate::backend::types::TokenInfo>, ApiError> {
let result = backend.get_token_info(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_get_session",
version = "v1",
path = "/auth/get-session",
method = "POST",
tool_name = "auth_get_session",
description = "获取 session"
)]
async fn get_session(
#[state] backend: Arc<dyn AuthBackend>,
req: GetSessionRequest,
) -> Result<ApiResponse<crate::backend::types::SessionData>, ApiError> {
let result = backend.get_session(&req.token).await;
match result {
Ok(mut session) => {
if !can_view_pii(
&backend,
&req.caller_login_id,
&session.login_id,
&req.caller_token,
)
.await
{
session.ip = None;
session.user_agent = None;
session.device = None;
}
Ok(to_api_response(Ok(session)))
},
Err(e) => Ok(to_api_response(Err(e))),
}
}
#[forge(
name = "auth_kickout",
version = "v1",
path = "/auth/kickout",
method = "POST",
tool_name = "auth_kickout",
description = "踢出登录主体"
)]
async fn kickout(
#[state] backend: Arc<dyn AuthBackend>,
req: KickoutRequest,
) -> Result<ApiResponse<()>, ApiError> {
if !can_kickout(
&backend,
&req.caller_login_id,
&req.login_id,
&req.caller_token,
)
.await
{
return Ok(to_api_response(Err(GarrisonError::NotPermission(
"server-caller-not-owner-kickout".to_string(),
))));
}
let result = backend.kickout(&req.login_id).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_switch_to",
version = "v1",
path = "/auth/switch-to",
method = "POST",
tool_name = "auth_switch_to",
description = "切换登录主体"
)]
async fn switch_to(
#[state] backend: Arc<dyn AuthBackend>,
req: SwitchToRequest,
) -> Result<ApiResponse<()>, ApiError> {
let session = backend.get_session(&req.token).await;
match session {
Ok(s) => {
if !can_switch_to(
&backend,
&req.caller_login_id,
&s.login_id,
&req.caller_token,
)
.await
{
return Ok(to_api_response(Err(GarrisonError::NotPermission(
"server-caller-not-owner-switch-to".to_string(),
))));
}
let result = backend.switch_to(&req.token, &req.target_login_id).await;
Ok(to_api_response(result))
},
Err(e) => Ok(to_api_response(Err(e))),
}
}
#[forge(
name = "auth_renew_to_equivalent",
version = "v1",
path = "/auth/renew-to-equivalent",
method = "POST",
tool_name = "auth_renew_to_equivalent",
description = "续期 token"
)]
async fn renew_to_equivalent(
#[state] backend: Arc<dyn AuthBackend>,
req: CheckLoginRequest,
) -> Result<ApiResponse<String>, ApiError> {
let result = backend.renew_to_equivalent(&req.token).await;
Ok(to_api_response(result))
}
#[forge(
name = "auth_health",
version = "v1",
path = "/auth/health",
method = "GET",
tool_name = "auth_health",
description = "健康检查"
)]
async fn health() -> Result<ApiResponse<&'static str>, ApiError> {
Ok(ApiResponse::ok("ok"))
}
#[cfg(feature = "metrics-prometheus")]
#[forge(
name = "auth_metrics",
version = "v1",
path = "/metrics",
method = "GET",
tool_name = "auth_metrics",
description = "Prometheus 指标端点"
)]
async fn metrics() -> Result<String, ApiError> {
let output = prometheus::TextEncoder::new()
.encode_to_string(&prometheus::gather())
.map_err(|e| {
ApiError::internal_with_source("Prometheus 指标编码失败", "metrics-encode-failure", e)
})?;
Ok(output)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::backend::types::LoginParams;
use crate::error::GarrisonError;
use async_trait::async_trait;
use axum::body::Body;
use axum::extract::Extension;
use axum::http::{Request, StatusCode};
use http_body_util::BodyExt;
use tower::ServiceExt;
struct MockAuthBackend;
#[async_trait]
impl AuthBackend for MockAuthBackend {
async fn login(
&self,
login_id: &str,
_params: &LoginParams,
) -> Result<String, GarrisonError> {
Ok(format!("token-{}", login_id))
}
async fn logout(&self, _token: &str) -> Result<(), GarrisonError> {
Ok(())
}
async fn check_login(&self, token: &str) -> Result<bool, GarrisonError> {
Ok(token.starts_with("valid-"))
}
async fn check_permission(
&self,
token: &str,
permission: &str,
) -> Result<(), GarrisonError> {
if token.is_empty() {
return Err(GarrisonError::InvalidToken(
"server-token-empty".to_string(),
));
}
if permission == "denied" {
return Err(GarrisonError::NotPermission(
"server-no-permission".to_string(),
));
}
Ok(())
}
async fn check_role(&self, _token: &str, _role: &str) -> Result<(), GarrisonError> {
Ok(())
}
async fn check_safe(&self, _token: &str) -> Result<bool, GarrisonError> {
Ok(true)
}
async fn check_disable(&self, _token: &str) -> Result<bool, GarrisonError> {
Ok(false)
}
async fn check_api_key(
&self,
api_key: &str,
_namespace: &str,
) -> Result<(), GarrisonError> {
if api_key == "invalid" {
return Err(GarrisonError::InvalidToken(
"server-apikey-invalid".to_string(),
));
}
Ok(())
}
async fn get_token_info(
&self,
token: &str,
) -> Result<crate::backend::types::TokenInfo, GarrisonError> {
Ok(crate::backend::types::TokenInfo {
token: token.to_string(),
created_at: 1000,
last_active_at: 2000,
})
}
async fn get_session(
&self,
token: &str,
) -> Result<crate::backend::types::SessionData, GarrisonError> {
Ok(crate::backend::types::SessionData {
token: token.to_string(),
login_id: "mock-user".to_string(),
created_at: 1000,
last_active_at: 2000,
attrs: std::collections::HashMap::new(),
device: Some("web-chrome".to_string()),
ip: Some("192.168.1.1".to_string()),
user_agent: Some("Mozilla/5.0".to_string()),
safe_services: std::collections::HashMap::new(),
#[cfg(feature = "dynamic-active-timeout")]
dynamic_active_timeout: None,
#[cfg(feature = "anonymous-session")]
is_anon: false,
})
}
async fn kickout(&self, _login_id: &str) -> Result<(), GarrisonError> {
Ok(())
}
async fn switch_to(
&self,
_token: &str,
_target_login_id: &str,
) -> Result<(), GarrisonError> {
Ok(())
}
async fn renew_to_equivalent(&self, token: &str) -> Result<String, GarrisonError> {
Ok(format!("renewed-{}", token))
}
}
fn make_backend() -> Arc<dyn AuthBackend> {
Arc::new(MockAuthBackend)
}
fn make_router() -> axum::Router {
sdforge::http::build().layer(Extension(make_backend()))
}
async fn post_json(
router: axum::Router,
uri: &str,
body: serde_json::Value,
) -> serde_json::Value {
let resp = router
.oneshot(
Request::builder()
.method("POST")
.uri(uri)
.header("content-type", "application/json")
.body(Body::from(body.to_string()))
.unwrap(),
)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
serde_json::from_slice(&bytes).unwrap()
}
#[tokio::test]
async fn test_sdforge_login_returns_token() {
let app = make_router();
let body = serde_json::json!({
"login_id": "user1",
"params": LoginParams::default()
});
let resp_json = post_json(app, "/api/v1/auth/login", body).await;
assert_eq!(resp_json["data"], "token-user1");
}
#[tokio::test]
async fn test_sdforge_logout_succeeds() {
let app = make_router();
let body = serde_json::json!({ "token": "some-token" });
let resp_json = post_json(app, "/api/v1/auth/logout", body).await;
assert!(resp_json.get("error_code").is_none() || resp_json["error_code"].is_null());
}
#[tokio::test]
async fn test_sdforge_refresh_returns_new_token() {
let app = make_router();
let body = serde_json::json!({ "token": "old-token" });
let resp_json = post_json(app, "/api/v1/auth/refresh", body).await;
assert_eq!(resp_json["data"], "renewed-old-token");
}
#[tokio::test]
async fn test_sdforge_check_login_returns_true() {
let app = make_router();
let body = serde_json::json!({ "token": "valid-token" });
let resp_json = post_json(app, "/api/v1/auth/check-login", body).await;
assert_eq!(resp_json["data"], true);
}
#[tokio::test]
async fn test_sdforge_check_login_returns_false() {
let app = make_router();
let body = serde_json::json!({ "token": "invalid-token" });
let resp_json = post_json(app, "/api/v1/auth/check-login", body).await;
assert_eq!(resp_json["data"], false);
}
#[tokio::test]
async fn test_sdforge_check_permission_succeeds() {
let app = make_router();
let body = serde_json::json!({ "token": "valid", "permission": "user:read" });
let resp_json = post_json(app, "/api/v1/auth/check-permission", body).await;
assert!(resp_json.get("error_code").is_none() || resp_json["error_code"].is_null());
}
#[tokio::test]
async fn test_sdforge_check_permission_denied() {
let app = make_router();
let body = serde_json::json!({ "token": "valid", "permission": "denied" });
let resp_json = post_json(app, "/api/v1/auth/check-permission", body).await;
assert_eq!(resp_json["error_code"], "NOT_PERMISSION");
}
#[tokio::test]
async fn test_sdforge_check_role_succeeds() {
let app = make_router();
let body = serde_json::json!({ "token": "valid", "role": "admin" });
let resp_json = post_json(app, "/api/v1/auth/check-role", body).await;
assert!(resp_json.get("error_code").is_none() || resp_json["error_code"].is_null());
}
#[tokio::test]
async fn test_sdforge_check_safe_returns_true() {
let app = make_router();
let body = serde_json::json!({ "token": "valid" });
let resp_json = post_json(app, "/api/v1/auth/check-safe", body).await;
assert_eq!(resp_json["data"], true);
}
#[tokio::test]
async fn test_sdforge_check_disable_returns_false() {
let app = make_router();
let body = serde_json::json!({ "token": "valid" });
let resp_json = post_json(app, "/api/v1/auth/check-disable", body).await;
assert_eq!(resp_json["data"], false);
}
#[tokio::test]
async fn test_sdforge_check_api_key_valid() {
let app = make_router();
let body = serde_json::json!({ "api_key": "valid-key", "namespace": "default" });
let resp_json = post_json(app, "/api/v1/auth/check-api-key", body).await;
assert!(resp_json.get("error_code").is_none() || resp_json["error_code"].is_null());
}
#[tokio::test]
async fn test_sdforge_check_api_key_invalid() {
let app = make_router();
let body = serde_json::json!({ "api_key": "invalid", "namespace": "default" });
let resp_json = post_json(app, "/api/v1/auth/check-api-key", body).await;
assert_eq!(resp_json["error_code"], "INVALID_TOKEN");
}
#[tokio::test]
async fn test_sdforge_get_token_info() {
let app = make_router();
let body = serde_json::json!({ "token": "my-token", "caller_login_id": "mock-user" });
let resp_json = post_json(app, "/api/v1/auth/get-token-info", body).await;
assert_eq!(resp_json["data"]["token"], "my-token");
assert_eq!(resp_json["data"]["created_at"], 1000);
}
#[tokio::test]
async fn test_sdforge_get_session() {
let app = make_router();
let body = serde_json::json!({
"token": "my-token",
"caller_login_id": "mock-user"
});
let resp_json = post_json(app, "/api/v1/auth/get-session", body).await;
assert_eq!(resp_json["data"]["token"], "my-token");
assert_eq!(resp_json["data"]["login_id"], "mock-user");
assert_eq!(resp_json["data"]["ip"], "192.168.1.1");
assert_eq!(resp_json["data"]["user_agent"], "Mozilla/5.0");
assert_eq!(resp_json["data"]["device"], "web-chrome");
}
#[tokio::test]
async fn test_sdforge_get_session_masks_pii_for_non_owner() {
let app = make_router();
let body = serde_json::json!({
"token": "my-token",
"caller_login_id": "attacker"
});
let resp_json = post_json(app, "/api/v1/auth/get-session", body).await;
assert_eq!(resp_json["data"]["token"], "my-token");
assert_eq!(resp_json["data"]["login_id"], "mock-user");
assert_eq!(resp_json["data"]["created_at"], 1000);
assert!(
resp_json["data"]["ip"].is_null(),
"非属主 ip 应被脱敏,实际: {:?}",
resp_json["data"]["ip"]
);
assert!(
resp_json["data"]["user_agent"].is_null(),
"非属主 user_agent 应被脱敏,实际: {:?}",
resp_json["data"]["user_agent"]
);
assert!(
resp_json["data"]["device"].is_null(),
"非属主 device 应被脱敏,实际: {:?}",
resp_json["data"]["device"]
);
}
#[tokio::test]
async fn test_sdforge_get_session_masks_pii_when_caller_login_id_empty() {
let app = make_router();
let body = serde_json::json!({ "token": "my-token" });
let resp_json = post_json(app, "/api/v1/auth/get-session", body).await;
assert_eq!(resp_json["data"]["login_id"], "mock-user");
assert!(
resp_json["data"]["ip"].is_null(),
"空 caller_login_id 时 ip 应被脱敏(fail-closed)"
);
assert!(
resp_json["data"]["user_agent"].is_null(),
"空 caller_login_id 时 user_agent 应被脱敏(fail-closed)"
);
assert!(
resp_json["data"]["device"].is_null(),
"空 caller_login_id 时 device 应被脱敏(fail-closed)"
);
}
#[tokio::test]
async fn test_sdforge_kickout_succeeds_for_owner() {
let app = make_router();
let body = serde_json::json!({
"login_id": "user1",
"caller_login_id": "user1"
});
let resp_json = post_json(app, "/api/v1/auth/kickout", body).await;
assert!(
resp_json.get("error_code").is_none() || resp_json["error_code"].is_null(),
"属主应允许 kickout,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_kickout_denies_non_owner() {
let app = make_router();
let body = serde_json::json!({
"login_id": "victim",
"caller_login_id": "attacker"
});
let resp_json = post_json(app, "/api/v1/auth/kickout", body).await;
assert!(
!resp_json["error_code"].is_null(),
"非属主应被拒绝 kickout,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_kickout_denies_empty_caller_login_id() {
let app = make_router();
let body = serde_json::json!({ "login_id": "user1" });
let resp_json = post_json(app, "/api/v1/auth/kickout", body).await;
assert!(
!resp_json["error_code"].is_null(),
"空 caller_login_id 应 fail-closed 拒绝,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_kickout_allows_admin_permission() {
let app = make_router();
let body = serde_json::json!({
"login_id": "victim",
"caller_login_id": "admin-user",
"caller_token": "admin-token"
});
let resp_json = post_json(app, "/api/v1/auth/kickout", body).await;
assert!(
resp_json.get("error_code").is_none() || resp_json["error_code"].is_null(),
"有 admin:sessions 权限应允许 kickout,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_switch_to_succeeds_for_owner() {
let app = make_router();
let body = serde_json::json!({
"token": "tok",
"target_login_id": "user2",
"caller_login_id": "mock-user"
});
let resp_json = post_json(app, "/api/v1/auth/switch-to", body).await;
assert!(
resp_json.get("error_code").is_none() || resp_json["error_code"].is_null(),
"属主应允许 switch_to,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_switch_to_denies_non_owner() {
let app = make_router();
let body = serde_json::json!({
"token": "tok",
"target_login_id": "user2",
"caller_login_id": "attacker"
});
let resp_json = post_json(app, "/api/v1/auth/switch-to", body).await;
assert!(
!resp_json["error_code"].is_null(),
"非属主应被拒绝,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_switch_to_denies_empty_caller_login_id() {
let app = make_router();
let body = serde_json::json!({ "token": "tok", "target_login_id": "user2" });
let resp_json = post_json(app, "/api/v1/auth/switch-to", body).await;
assert!(
!resp_json["error_code"].is_null(),
"空 caller_login_id 应 fail-closed 拒绝,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_switch_to_allows_admin_permission() {
let app = make_router();
let body = serde_json::json!({
"token": "tok",
"target_login_id": "user2",
"caller_login_id": "admin-user",
"caller_token": "admin-token"
});
let resp_json = post_json(app, "/api/v1/auth/switch-to", body).await;
assert!(
resp_json.get("error_code").is_none() || resp_json["error_code"].is_null(),
"有 admin:sessions 权限应允许,实际: {:?}",
resp_json
);
}
#[tokio::test]
async fn test_sdforge_renew_to_equivalent() {
let app = make_router();
let body = serde_json::json!({ "token": "old-token" });
let resp_json = post_json(app, "/api/v1/auth/renew-to-equivalent", body).await;
assert_eq!(resp_json["data"], "renewed-old-token");
}
#[tokio::test]
async fn test_sdforge_health() {
let app = make_router();
let resp = app
.oneshot(
Request::builder()
.method("GET")
.uri("/api/v1/auth/health")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
let resp_json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(resp_json["data"], "ok");
}
#[test]
fn test_sdforge_route_count() {
let router = sdforge::http::build();
let route_count = count_routes(&router);
#[cfg(feature = "metrics-prometheus")]
let expected = 16;
#[cfg(not(feature = "metrics-prometheus"))]
let expected = 15;
assert_eq!(
route_count, expected,
"sdforge 应注册 {} 个路由,实际 {}",
expected, route_count
);
}
fn count_routes(_router: &axum::Router) -> usize {
let reg_count = inventory::iter::<sdforge::http::RouteRegistration>
.into_iter()
.count();
let direct_count = inventory::iter::<sdforge::http::HttpRoute>
.into_iter()
.count();
reg_count + direct_count
}
#[cfg(feature = "metrics-prometheus")]
#[tokio::test]
#[serial_test::serial]
async fn test_sdforge_metrics_returns_prometheus_format() {
use crate::observability::GarrisonMetrics;
if let Ok(metrics) = GarrisonMetrics::register_to(prometheus::default_registry()) {
metrics.record_login(true);
metrics.record_permission_query(true);
}
let app = make_router();
let resp = app
.oneshot(
Request::builder()
.method("GET")
.uri("/api/v1/metrics")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
let body: String = serde_json::from_slice(&bytes).expect("响应应为 JSON 序列化的字符串");
assert!(
body.contains("garrison_login_total"),
"/metrics 应包含 garrison_login_total 指标,实际: {}",
body
);
}
#[cfg(feature = "metrics-prometheus")]
#[tokio::test]
#[serial_test::serial]
async fn test_sdforge_metrics_returns_empty_when_no_metrics() {
let app = make_router();
let resp = app
.oneshot(
Request::builder()
.method("GET")
.uri("/api/v1/metrics")
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
let bytes = resp.into_body().collect().await.unwrap().to_bytes();
let _body: String = serde_json::from_slice(&bytes).expect("响应应为 JSON 序列化的字符串");
}
}