#[cfg(all(test, feature = "metrics-prometheus"))]
mod tests_metrics {
use super::super::*;
use serial_test::serial;
use std::time::Duration;
#[test]
#[serial]
fn test_metrics_new_with_custom_registry() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册到自定义 registry 失败");
metrics.record_login(true);
metrics.observe_token_validation(Duration::from_millis(1));
metrics.record_permission_query(true);
metrics.record_role_query(true);
let gathered = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(
gathered.contains("garrison_login_total"),
"missing login_total: {}",
gathered
);
assert!(
gathered.contains("garrison_token_validation_duration_seconds"),
"missing token_validation: {}",
gathered
);
assert!(
gathered.contains("garrison_permission_query_total"),
"missing permission_query: {}",
gathered
);
assert!(
gathered.contains("garrison_role_query_total"),
"missing role_query: {}",
gathered
);
}
#[test]
#[serial]
fn test_record_login_success() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(true);
metrics.record_login(true);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_login_total{result=\"success\"} 2"));
}
#[test]
#[serial]
fn test_record_login_failure() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_login_total{result=\"failure\"} 1"));
}
#[test]
#[serial]
fn test_observe_token_validation_duration() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.observe_token_validation(Duration::from_millis(5));
metrics.observe_token_validation(Duration::from_millis(50));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_token_validation_duration_seconds_count 2"));
}
#[test]
#[serial]
fn test_record_permission_query() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_permission_query(true);
metrics.record_permission_query(true);
metrics.record_permission_query(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_permission_query_total{result=\"allow\"} 2"));
assert!(output.contains("garrison_permission_query_total{result=\"deny\"} 1"));
}
#[test]
#[serial]
fn test_record_role_query() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_role_query(true);
metrics.record_role_query(false);
metrics.record_role_query(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_role_query_total{result=\"allow\"} 1"));
assert!(output.contains("garrison_role_query_total{result=\"deny\"} 2"));
}
#[test]
#[serial]
fn test_gather_returns_text_format() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(true);
metrics.record_permission_query(true);
let _output: String = metrics.gather();
}
#[test]
#[serial]
fn test_default_impl_via_register_to() {
let registry = prometheus::Registry::new();
let _m1 = GarrisonMetrics::register_to(®istry).expect("注册失败");
}
#[test]
#[serial]
fn test_duplicate_register_returns_error() {
let registry = prometheus::Registry::new();
let _m1 = GarrisonMetrics::register_to(®istry).expect("首次注册失败");
let result = GarrisonMetrics::register_to(®istry);
assert!(result.is_err(), "重复注册应返回错误");
match result {
Err(prometheus::Error::AlreadyReg) => {},
Err(e) => panic!("期望 AlreadyReg 错误,实际:{:?}", e),
Ok(_) => panic!("期望错误,实际成功"),
}
}
#[test]
#[serial]
fn test_new_repeated_does_not_panic() {
let _m1 = GarrisonMetrics::new();
let _m2 = GarrisonMetrics::new();
let _m3 = GarrisonMetrics::default();
_m3.record_login(true);
let _ = _m3.gather();
}
#[test]
#[serial]
fn test_metrics_clone() {
let registry = prometheus::Registry::new();
let m1 = GarrisonMetrics::register_to(®istry).expect("注册失败");
let m2 = m1.clone();
m1.record_login(true);
m2.record_login(true);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_login_total{result=\"success\"} 2"));
}
#[test]
#[serial]
fn test_metrics_debug_impl() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
let debug_str = format!("{:?}", metrics);
assert!(debug_str.contains("GarrisonMetrics"));
assert!(debug_str.contains("CounterVec"));
assert!(debug_str.contains("Histogram"));
}
#[test]
#[serial]
fn test_default_impl_creates_instance() {
let metrics = GarrisonMetrics::default();
metrics.record_login(true);
metrics.record_permission_query(false);
}
#[test]
#[serial]
fn test_new_registers_to_default_registry() {
let registry = prometheus::Registry::new();
let _metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
}
#[test]
#[serial]
fn test_observe_token_validation_zero_duration() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.observe_token_validation(Duration::from_millis(0));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_token_validation_duration_seconds_count 1"));
}
#[test]
#[serial]
fn test_all_record_operations_on_single_instance() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(true);
metrics.record_login(false);
metrics.observe_token_validation(Duration::from_millis(10));
metrics.record_permission_query(true);
metrics.record_permission_query(false);
metrics.record_role_query(true);
metrics.record_role_query(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_login_total{result=\"success\"} 1"));
assert!(output.contains("garrison_login_total{result=\"failure\"} 1"));
assert!(output.contains("garrison_permission_query_total{result=\"allow\"} 1"));
assert!(output.contains("garrison_permission_query_total{result=\"deny\"} 1"));
assert!(output.contains("garrison_role_query_total{result=\"allow\"} 1"));
assert!(output.contains("garrison_role_query_total{result=\"deny\"} 1"));
}
#[test]
#[serial]
fn test_gather_returns_non_empty_after_operations() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(true);
metrics.observe_token_validation(Duration::from_millis(5));
metrics.record_permission_query(true);
metrics.record_role_query(true);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(!output.is_empty(), "gather() 不应返回空字符串");
assert!(
output.contains("garrison_login_total"),
"gather 应含 login_total"
);
assert!(
output.contains("garrison_token_validation_duration_seconds"),
"gather 应含 token_validation"
);
assert!(
output.contains("garrison_permission_query_total"),
"gather 应含 permission_query"
);
assert!(
output.contains("garrison_role_query_total"),
"gather 应含 role_query"
);
}
#[test]
#[serial]
fn test_two_registries_independent() {
let registry1 = prometheus::Registry::new();
let registry2 = prometheus::Registry::new();
let m1 = GarrisonMetrics::register_to(®istry1).expect("注册失败");
let m2 = GarrisonMetrics::register_to(®istry2).expect("注册失败");
m1.record_login(true);
m2.record_login(false);
let out1 = prometheus::TextEncoder::new()
.encode_to_string(®istry1.gather())
.expect("encode 失败");
let out2 = prometheus::TextEncoder::new()
.encode_to_string(®istry2.gather())
.expect("encode 失败");
assert!(out1.contains("garrison_login_total{result=\"success\"} 1"));
assert!(!out1.contains("result=\"failure\""));
assert!(out2.contains("garrison_login_total{result=\"failure\"} 1"));
assert!(!out2.contains("result=\"success\""));
}
#[test]
#[serial]
fn test_record_login_success_and_failure_on_same_instance() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_login(true);
metrics.record_login(true);
metrics.record_login(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_login_total{result=\"success\"} 2"));
assert!(output.contains("garrison_login_total{result=\"failure\"} 1"));
}
#[test]
#[serial]
fn test_observe_token_validation_multiple_values_count_and_sum() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.observe_token_validation(Duration::from_millis(100));
metrics.observe_token_validation(Duration::from_millis(200));
metrics.observe_token_validation(Duration::from_millis(300));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_token_validation_duration_seconds_count 3"));
}
#[test]
#[serial]
fn test_record_permission_query_allow_and_deny_on_same_instance() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_permission_query(true);
metrics.record_permission_query(true);
metrics.record_permission_query(true);
metrics.record_permission_query(false);
metrics.record_permission_query(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_permission_query_total{result=\"allow\"} 3"));
assert!(output.contains("garrison_permission_query_total{result=\"deny\"} 2"));
}
#[test]
#[serial]
fn test_record_role_query_allow_and_deny_on_same_instance() {
let registry = prometheus::Registry::new();
let metrics = GarrisonMetrics::register_to(®istry).expect("注册失败");
metrics.record_role_query(false);
metrics.record_role_query(false);
metrics.record_role_query(false);
metrics.record_role_query(true);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(output.contains("garrison_role_query_total{result=\"allow\"} 1"));
assert!(output.contains("garrison_role_query_total{result=\"deny\"} 3"));
}
}
#[cfg(all(test, feature = "otlp"))]
mod tests_otlp {
use super::super::*;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_init_otlp_tracing_succeeds() {
let result = init_otlp_tracing("http://localhost:4317");
assert!(
result.is_ok(),
"init_otlp_tracing 应成功: {:?}",
result.err()
);
}
#[tokio::test]
#[serial]
async fn test_init_otlp_tracing_invalid_endpoint_returns_err() {
let result = init_otlp_tracing("not a valid endpoint");
assert!(result.is_err(), "非法 endpoint 应返回 Err");
let err = result.unwrap_err();
assert!(
matches!(err, GarrisonOtelError::Exporter(_)),
"应映射为 Exporter 变体,实际: {:?}",
err
);
let msg = format!("{}", err);
assert!(msg.contains("OTLP exporter"), "实际: {}", msg);
}
#[test]
fn test_otel_error_display() {
let err1 = GarrisonOtelError::Exporter("exporter 失败".to_string());
assert!(format!("{}", err1).contains("exporter 失败"));
assert!(format!("{}", err1).contains("OTLP exporter"));
let err2 = GarrisonOtelError::Provider("provider 失败".to_string());
assert!(format!("{}", err2).contains("provider 失败"));
assert!(format!("{}", err2).contains("Tracer provider"));
}
#[test]
fn test_otel_error_debug() {
let err = GarrisonOtelError::Exporter("test".to_string());
let debug_str = format!("{:?}", err);
assert!(debug_str.contains("Exporter"));
assert!(debug_str.contains("test"));
let err2 = GarrisonOtelError::Provider("prov".to_string());
let debug_str2 = format!("{:?}", err2);
assert!(debug_str2.contains("Provider"));
assert!(debug_str2.contains("prov"));
}
}
#[cfg(all(test, not(feature = "metrics-prometheus")))]
mod tests_no_feature {
use super::super::*;
#[test]
fn test_no_feature_metrics_is_unit() {
let _: GarrisonMetrics = ();
}
}
#[cfg(all(test, feature = "audit-inklog"))]
mod tests_inklog {
use super::super::*;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn init_inklog_logging_succeeds() {
let result = init_inklog_logging().await;
assert!(
result.is_ok(),
"init_inklog_logging 应成功: {:?}",
result.err()
);
}
#[tokio::test]
#[serial]
async fn init_inklog_logging_reads_rust_log() {
std::env::set_var("RUST_LOG", "debug");
let result = init_inklog_logging().await;
std::env::remove_var("RUST_LOG");
assert!(
result.is_ok(),
"init_inklog_logging 应成功(debug level): {:?}",
result.err()
);
}
#[tokio::test]
#[serial]
async fn m4_init_with_fallback_succeeds_not_degraded() {
let result = init_inklog_logging_with_fallback().await;
assert!(!result.is_degraded(), "inklog 初始化成功时不应降级");
assert!(result.guard().is_some(), "成功时应返回 LoggerManager guard");
}
#[tokio::test]
#[serial]
async fn m4_inklog_init_degraded_flag() {
let degraded = InklogInit {
guard: None,
degraded: true,
};
assert!(degraded.is_degraded());
assert!(degraded.guard().is_none());
let normal = InklogInit {
guard: None, degraded: false,
};
assert!(!normal.is_degraded());
}
#[tokio::test]
#[serial]
async fn init_inklog_logging_fails_on_invalid_level() {
std::env::set_var("RUST_LOG", "not-a-valid-level");
let result = init_inklog_logging().await;
std::env::remove_var("RUST_LOG");
assert!(result.is_err(), "非法 level 应使 inklog 初始化失败");
}
#[tokio::test]
#[serial]
async fn r_dep003_fallback_degrades_when_inklog_fails() {
std::env::set_var("RUST_LOG", "garrison-bogus-level");
let result = init_inklog_logging_with_fallback().await;
std::env::remove_var("RUST_LOG");
assert!(result.is_degraded(), "inklog 失败时应降级(degraded=true)");
assert!(
result.guard().is_none(),
"降级时不应持有 LoggerManager guard"
);
}
}