use crate::error::GarrisonError;
use fluent::concurrent::FluentBundle;
use fluent::{FluentArgs, FluentResource};
use once_cell::sync::OnceCell;
use std::cell::RefCell;
use unic_langid::LanguageIdentifier;
#[macro_export]
macro_rules! loc {
($key:expr, $fallback:expr $(, ($arg_k:expr, $arg_v:expr))*) => {{
$crate::i18n::translate_detail($key, &[$(($arg_k, $arg_v)),*])
}};
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum GarrisonLocale {
#[default]
Zh,
En,
}
impl GarrisonLocale {
fn as_lang_id(self) -> LanguageIdentifier {
match self {
GarrisonLocale::Zh => "zh".parse().expect("valid language identifier"),
GarrisonLocale::En => "en".parse().expect("valid language identifier"),
}
}
}
thread_local! {
static CURRENT_LOCALE_STACK: RefCell<Vec<GarrisonLocale>> = const { RefCell::new(Vec::new()) };
}
pub fn current_locale() -> GarrisonLocale {
CURRENT_LOCALE_STACK.with(|stack| stack.borrow().last().copied().unwrap_or_default())
}
pub fn set_locale(locale: GarrisonLocale) -> LocaleGuard {
CURRENT_LOCALE_STACK.with(|stack| stack.borrow_mut().push(locale));
LocaleGuard { _priv: () }
}
pub struct LocaleGuard {
_priv: (),
}
impl Drop for LocaleGuard {
fn drop(&mut self) {
CURRENT_LOCALE_STACK.with(|stack| {
stack.borrow_mut().pop();
});
}
}
static ZH_BUNDLE: OnceCell<FluentBundle<FluentResource>> = OnceCell::new();
static EN_BUNDLE: OnceCell<FluentBundle<FluentResource>> = OnceCell::new();
fn get_bundle(locale: GarrisonLocale) -> &'static FluentBundle<FluentResource> {
match locale {
GarrisonLocale::Zh => ZH_BUNDLE.get_or_init(|| build_bundle(GarrisonLocale::Zh)),
GarrisonLocale::En => EN_BUNDLE.get_or_init(|| build_bundle(GarrisonLocale::En)),
}
}
fn build_bundle(locale: GarrisonLocale) -> FluentBundle<FluentResource> {
let ftl = match locale {
GarrisonLocale::Zh => include_str!("../locales/zh.ftl"),
GarrisonLocale::En => include_str!("../locales/en.ftl"),
};
let resource = FluentResource::try_new(ftl.to_string())
.expect("Garrison .ftl 资源解析失败(编译期已固化,不应失败)");
let lang_id = locale.as_lang_id();
let mut bundle = FluentBundle::new_concurrent(vec![lang_id]);
bundle.set_use_isolating(false);
bundle
.add_resource(resource)
.expect("Garrison .ftl 资源添加到 bundle 失败(资源键冲突不应发生)");
bundle
}
pub fn translate_error(err: &GarrisonError) -> String {
let locale = current_locale();
let bundle = get_bundle(locale);
let (key, args) = error_to_key_args(err);
match bundle.get_message(key) {
Some(msg) => match msg.value() {
Some(pattern) => {
let mut fluent_args = FluentArgs::new();
for (k, v) in args {
fluent_args.set(k, v);
}
let mut errors = vec![];
let value = bundle.format_pattern(pattern, Some(&fluent_args), &mut errors);
if errors.is_empty() {
value.into_owned()
} else {
fallback_display(err)
}
},
None => fallback_display(err),
},
None => fallback_display(err),
}
}
pub fn translate_detail(key: &str, args: &[(&str, &str)]) -> String {
let locale = current_locale();
let bundle = get_bundle(locale);
match bundle.get_message(key) {
Some(msg) => match msg.value() {
Some(pattern) => {
let mut errors = vec![];
let value = if args.is_empty() {
bundle.format_pattern(pattern, None, &mut errors)
} else {
let mut fluent_args = FluentArgs::new();
for (k, v) in args {
fluent_args.set(*k, (*v).to_string());
}
bundle.format_pattern(pattern, Some(&fluent_args), &mut errors)
};
if errors.is_empty() {
value.into_owned()
} else {
key.to_string()
}
},
None => key.to_string(),
},
None => key.to_string(),
}
}
fn parse_keyed_detail(s: &str) -> Option<(&'static str, Vec<(&'static str, String)>)> {
if !s.contains("::") {
return None;
}
let mut parts = s.splitn(3, "::");
let key = parts.next()?;
if key.is_empty() || !key.chars().next().unwrap().is_ascii_alphabetic() {
return None;
}
if key.chars().any(|c| !c.is_ascii_lowercase() && c != '-') {
return None;
}
let a0 = parts.next();
let a1 = parts.next();
match (a0, a1) {
(None, None) | (None, Some(_)) => {
Some((Box::leak(key.to_string().into_boxed_str()), vec![]))
},
(Some(x), None) => Some((
Box::leak(key.to_string().into_boxed_str()),
vec![("arg0", x.to_string())],
)),
(Some(x), Some(y)) => Some((
Box::leak(key.to_string().into_boxed_str()),
vec![("arg0", x.to_string()), ("arg1", y.to_string())],
)),
}
}
fn string_detail(
variant_key: &'static str,
s: &str,
) -> (&'static str, Vec<(&'static str, String)>) {
match parse_keyed_detail(s) {
Some((k, args)) => (k, args),
None => (variant_key, vec![("detail", s.to_string())]),
}
}
fn error_to_key_args(err: &GarrisonError) -> (&'static str, Vec<(&'static str, String)>) {
match err {
GarrisonError::NotLogin(s) => string_detail("not-login", s),
GarrisonError::NotPermission(s) => string_detail("not-permission", s),
GarrisonError::NotRole(s) => string_detail("not-role", s),
GarrisonError::InvalidToken(s) => string_detail("invalid-token", s),
GarrisonError::TokenRevoked(s) => string_detail("token-revoked", s),
GarrisonError::ExpiredToken(s) => string_detail("expired-token", s),
GarrisonError::Dao(s) => string_detail("dao", s),
GarrisonError::Config(s) => string_detail("config", s),
GarrisonError::Internal(s) => string_detail("internal", s),
GarrisonError::Session(s) => string_detail("session", s),
GarrisonError::Annotation(s) => string_detail("annotation", s),
GarrisonError::Context(s) => string_detail("context", s),
GarrisonError::OAuth2(s) => string_detail("oauth2", s),
GarrisonError::Network(s) => string_detail("network", s),
GarrisonError::InvalidParam(s) => string_detail("invalid-param", s),
GarrisonError::NotImplemented(s) => string_detail("not-implemented", s),
GarrisonError::FirewallBlocked(s) => string_detail("firewall-blocked", s),
GarrisonError::DisableService { service, until } => (
"disable-service",
vec![
("service", service.clone()),
("until", format!("{:?}", until)),
],
),
GarrisonError::NotSafe { reason } => ("not-safe", vec![("reason", reason.clone())]),
GarrisonError::InvalidStateTransition { from, to } => (
"invalid-state-transition",
vec![("from", from.clone()), ("to", to.clone())],
),
GarrisonError::SmsRateLimitExceeded { window } => {
("sms-rate-limit-exceeded", vec![("window", window.clone())])
},
GarrisonError::SmsVerifyMaxAttempts => ("sms-verify-max-attempts", vec![]),
GarrisonError::SmsCodeNotFound => ("sms-code-not-found", vec![]),
GarrisonError::SmsChannelRecycled => ("sms-channel-recycled", vec![]),
GarrisonError::Exception(ex) => (
"exception",
vec![
("code", ex.code.to_string()),
("detail", ex.message.clone()),
],
),
}
}
fn fallback_display(err: &GarrisonError) -> String {
match err {
GarrisonError::NotLogin(s) => format!("未登录: {}", s),
GarrisonError::NotPermission(s) => format!("无权限: {}", s),
GarrisonError::NotRole(s) => format!("无角色: {}", s),
GarrisonError::InvalidToken(s) => format!("Token 无效: {}", s),
GarrisonError::TokenRevoked(s) => format!("Token 已吊销: {}", s),
GarrisonError::ExpiredToken(s) => format!("Token 已过期: {}", s),
GarrisonError::Dao(s) => format!("DAO 错误: {}", s),
GarrisonError::Config(s) => format!("配置错误: {}", s),
GarrisonError::Internal(s) => format!("内部错误: {}", s),
GarrisonError::Session(s) => format!("会话错误: {}", s),
GarrisonError::Annotation(s) => format!("注解错误: {}", s),
GarrisonError::Context(s) => format!("上下文错误: {}", s),
GarrisonError::OAuth2(s) => format!("OAuth2 错误: {}", s),
GarrisonError::Network(s) => format!("网络错误: {}", s),
GarrisonError::InvalidParam(s) => format!("参数无效: {}", s),
GarrisonError::NotImplemented(s) => format!("未实现: {}", s),
GarrisonError::FirewallBlocked(s) => format!("防火墙拦截: {}", s),
GarrisonError::DisableService { service, until } => {
format!("账号已被封禁:service={}, until={:?}", service, until)
},
GarrisonError::NotSafe { reason } => format!("未完成二次认证:{}", reason),
GarrisonError::InvalidStateTransition { from, to } => {
format!("非法状态转换:{} -> {}", from, to)
},
GarrisonError::SmsRateLimitExceeded { window } => {
format!("SMS 限速超出: {} 窗口", window)
},
GarrisonError::SmsVerifyMaxAttempts => "SMS 验证码尝试次数超限".to_string(),
GarrisonError::SmsCodeNotFound => "SMS 验证码不存在".to_string(),
GarrisonError::SmsChannelRecycled => "SMS 通道已回收".to_string(),
GarrisonError::Exception(ex) => format!("业务异常[{}]: {}", ex.code, ex.message),
}
}
#[cfg(feature = "i18n-icu")]
pub mod icu_enhanced {
use crate::i18n::{current_locale, GarrisonLocale};
use chrono::{Datelike, Timelike};
use fixed_decimal::Decimal;
use icu_datetime::fieldsets;
use icu_datetime::DateTimeFormatter;
use icu_decimal::DecimalFormatter;
use icu_locale_core::{locale, Locale};
use icu_plurals::{PluralCategory, PluralRules};
fn to_icu_locale(l: GarrisonLocale) -> Locale {
match l {
GarrisonLocale::Zh => locale!("zh"),
GarrisonLocale::En => locale!("en"),
}
}
pub fn plural_category(count: usize) -> PluralCategory {
let rules =
PluralRules::try_new(to_icu_locale(current_locale()).into(), Default::default())
.expect("ICU PluralRules compiled_data 已编译,不应失败");
rules.category_for(count)
}
pub fn format_datetime_locale(dt: &chrono::DateTime<chrono::Utc>) -> String {
let icu_locale = to_icu_locale(current_locale());
let formatter = DateTimeFormatter::try_new(icu_locale.into(), fieldsets::YMDT::medium())
.expect("ICU DateTimeFormatter compiled_data 已编译,不应失败");
let date = icu_calendar::Date::try_new_iso(dt.year(), dt.month() as u8, dt.day() as u8)
.expect("chrono 日期转 ICU Date 不应失败");
let time =
icu_time::Time::try_new(dt.hour() as u8, dt.minute() as u8, dt.second() as u8, 0)
.expect("chrono 时间转 ICU Time 不应失败");
let datetime = icu_datetime::input::DateTime { date, time };
formatter.format(&datetime).to_string()
}
pub fn format_number_locale(n: i64) -> String {
let decimal = Decimal::from(n);
let formatter =
DecimalFormatter::try_new(to_icu_locale(current_locale()).into(), Default::default())
.expect("ICU DecimalFormatter compiled_data 已编译,不应失败");
formatter.format_to_string(&decimal)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::GarrisonError;
use crate::exception::GarrisonException;
#[test]
fn default_locale_is_zh() {
let locale = GarrisonLocale::default();
assert_eq!(locale, GarrisonLocale::Zh);
}
#[test]
fn as_lang_id_returns_correct_identifier() {
assert_eq!(GarrisonLocale::Zh.as_lang_id().to_string(), "zh");
assert_eq!(GarrisonLocale::En.as_lang_id().to_string(), "en");
}
#[test]
fn current_locale_defaults_to_zh_when_not_set() {
let locale = current_locale();
assert_eq!(locale, GarrisonLocale::Zh);
}
#[test]
fn set_locale_changes_current_and_restores_on_drop() {
let original = current_locale();
{
let _guard = set_locale(GarrisonLocale::En);
assert_eq!(current_locale(), GarrisonLocale::En);
}
assert_eq!(current_locale(), original);
}
#[test]
fn set_locale_supports_nesting() {
let original = current_locale();
{
let _g1 = set_locale(GarrisonLocale::En);
assert_eq!(current_locale(), GarrisonLocale::En);
{
let _g2 = set_locale(GarrisonLocale::Zh);
assert_eq!(current_locale(), GarrisonLocale::Zh);
}
assert_eq!(current_locale(), GarrisonLocale::En);
}
assert_eq!(current_locale(), original);
}
#[test]
fn translate_error_zh_returns_chinese_message() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::NotLogin("请先登录".to_string());
let translated = translate_error(&err);
assert_eq!(translated, "未登录: 请先登录");
}
#[test]
fn translate_error_en_returns_english_message() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::NotLogin("please login first".to_string());
let translated = translate_error(&err);
assert_eq!(translated, "Not logged in: please login first");
}
#[test]
fn translate_error_zh_all_variants_match_hardcoded() {
let _guard = set_locale(GarrisonLocale::Zh);
let cases = vec![
(GarrisonError::NotLogin("a".into()), "未登录: a"),
(GarrisonError::NotPermission("a".into()), "无权限: a"),
(GarrisonError::NotRole("a".into()), "无角色: a"),
(GarrisonError::InvalidToken("a".into()), "Token 无效: a"),
(GarrisonError::ExpiredToken("a".into()), "Token 已过期: a"),
(GarrisonError::Dao("a".into()), "DAO 错误: a"),
(GarrisonError::Config("a".into()), "配置错误: a"),
(GarrisonError::Internal("a".into()), "内部错误: a"),
(GarrisonError::Session("a".into()), "会话错误: a"),
(GarrisonError::Annotation("a".into()), "注解错误: a"),
(GarrisonError::Context("a".into()), "上下文错误: a"),
(GarrisonError::OAuth2("a".into()), "OAuth2 错误: a"),
(GarrisonError::Network("a".into()), "网络错误: a"),
(GarrisonError::InvalidParam("a".into()), "参数无效: a"),
(GarrisonError::NotImplemented("a".into()), "未实现: a"),
];
for (err, expected) in cases {
assert_eq!(translate_error(&err), expected, "mismatch for {:?}", err);
}
}
#[test]
fn translate_error_en_all_variants_english() {
let _guard = set_locale(GarrisonLocale::En);
let cases = vec![
(GarrisonError::NotLogin("a".into()), "Not logged in: a"),
(
GarrisonError::NotPermission("a".into()),
"Permission denied: a",
),
(GarrisonError::NotRole("a".into()), "Role denied: a"),
(GarrisonError::InvalidToken("a".into()), "Invalid token: a"),
(GarrisonError::ExpiredToken("a".into()), "Token expired: a"),
(GarrisonError::Dao("a".into()), "DAO error: a"),
(GarrisonError::Config("a".into()), "Configuration error: a"),
(GarrisonError::Internal("a".into()), "Internal error: a"),
(GarrisonError::Session("a".into()), "Session error: a"),
(GarrisonError::Annotation("a".into()), "Annotation error: a"),
(GarrisonError::Context("a".into()), "Context error: a"),
(GarrisonError::OAuth2("a".into()), "OAuth2 error: a"),
(GarrisonError::Network("a".into()), "Network error: a"),
(
GarrisonError::InvalidParam("a".into()),
"Invalid parameter: a",
),
(
GarrisonError::NotImplemented("a".into()),
"Not implemented: a",
),
];
for (err, expected) in cases {
assert_eq!(translate_error(&err), expected, "mismatch for {:?}", err);
}
}
#[test]
fn translate_error_zh_exception_variant() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::Exception(GarrisonException::new(-1, "请先登录"));
assert_eq!(translate_error(&err), "业务异常[-1]: 请先登录");
}
#[test]
fn translate_error_en_exception_variant() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::Exception(GarrisonException::new(-1, "please login"));
assert_eq!(
translate_error(&err),
"Business exception[-1]: please login"
);
}
#[test]
fn locale_switch_is_isolated_per_scope() {
let original = current_locale();
{
let _g = set_locale(GarrisonLocale::En);
let err = GarrisonError::Dao("err".to_string());
assert_eq!(translate_error(&err), "DAO error: err");
}
let err = GarrisonError::Dao("err".to_string());
if original == GarrisonLocale::En {
assert_eq!(translate_error(&err), "DAO error: err");
} else {
assert_eq!(translate_error(&err), "DAO 错误: err");
}
}
#[test]
fn fallback_display_matches_hardcoded_chinese() {
let err = GarrisonError::NotLogin("测试".to_string());
assert_eq!(fallback_display(&err), "未登录: 测试");
}
#[test]
fn fallback_display_all_variants() {
let cases: Vec<(GarrisonError, &str)> = vec![
(GarrisonError::NotLogin("x".into()), "未登录: x"),
(GarrisonError::NotPermission("x".into()), "无权限: x"),
(GarrisonError::NotRole("x".into()), "无角色: x"),
(GarrisonError::InvalidToken("x".into()), "Token 无效: x"),
(GarrisonError::ExpiredToken("x".into()), "Token 已过期: x"),
(GarrisonError::Dao("x".into()), "DAO 错误: x"),
(GarrisonError::Config("x".into()), "配置错误: x"),
(GarrisonError::Internal("x".into()), "内部错误: x"),
(GarrisonError::Session("x".into()), "会话错误: x"),
(GarrisonError::Annotation("x".into()), "注解错误: x"),
(GarrisonError::Context("x".into()), "上下文错误: x"),
(GarrisonError::OAuth2("x".into()), "OAuth2 错误: x"),
(GarrisonError::Network("x".into()), "网络错误: x"),
(GarrisonError::InvalidParam("x".into()), "参数无效: x"),
(GarrisonError::NotImplemented("x".into()), "未实现: x"),
(
GarrisonError::Exception(GarrisonException::new(-1, "msg")),
"业务异常[-1]: msg",
),
];
for (err, expected) in cases {
assert_eq!(fallback_display(&err), expected, "mismatch for {:?}", err);
}
}
#[test]
fn get_bundle_returns_cached_instance() {
let b1 = get_bundle(GarrisonLocale::Zh);
let b2 = get_bundle(GarrisonLocale::Zh);
assert!(std::ptr::eq(b1, b2));
}
#[test]
fn translate_detail_zh_returns_translated_message() {
let _guard = set_locale(GarrisonLocale::Zh);
let msg = translate_detail("not-login", &[("detail", "请先登录")]);
assert_eq!(msg, "未登录: 请先登录");
}
#[test]
fn translate_detail_en_returns_translated_message() {
let _guard = set_locale(GarrisonLocale::En);
let msg = translate_detail("not-login", &[("detail", "please login")]);
assert_eq!(msg, "Not logged in: please login");
}
#[test]
fn translate_detail_missing_key_returns_key() {
let _guard = set_locale(GarrisonLocale::Zh);
let msg = translate_detail("nonexistent-key-xyz", &[]);
assert_eq!(msg, "nonexistent-key-xyz");
}
#[test]
fn translate_detail_no_args_translates_successfully() {
let _guard = set_locale(GarrisonLocale::Zh);
let msg = translate_detail("sms-verify-max-attempts", &[]);
assert_eq!(msg, "SMS 验证码尝试次数超限");
}
#[test]
fn translate_detail_multiple_args_zh() {
let _guard = set_locale(GarrisonLocale::Zh);
let msg = translate_detail(
"disable-service",
&[
("service", "default"),
("until", "Some(2026-01-01T00:00:00Z)"),
],
);
assert!(msg.contains("service=default"));
assert!(msg.contains("账号已被封禁"));
}
#[test]
fn translate_detail_multiple_args_en() {
let _guard = set_locale(GarrisonLocale::En);
let msg = translate_detail(
"invalid-state-transition",
&[("from", "Active"), ("to", "Closed")],
);
assert_eq!(msg, "Invalid state transition: Active -> Closed");
}
#[test]
fn translate_error_zh_token_revoked() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::TokenRevoked("reuse detected".to_string());
let translated = translate_error(&err);
assert_eq!(translated, "Token 已吊销: reuse detected");
}
#[test]
fn translate_error_en_token_revoked() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::TokenRevoked("reuse detected".to_string());
let translated = translate_error(&err);
assert_eq!(translated, "Token 已吊销: reuse detected");
}
#[test]
fn translate_error_zh_firewall_blocked() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::FirewallBlocked("black_path: /admin".to_string());
let translated = translate_error(&err);
assert_eq!(translated, "防火墙拦截: black_path: /admin");
}
#[test]
fn translate_error_zh_disable_service() {
let _guard = set_locale(GarrisonLocale::Zh);
let until = chrono::DateTime::parse_from_rfc3339("2026-01-01T00:00:00Z")
.unwrap()
.with_timezone(&chrono::Utc);
let err = GarrisonError::DisableService {
service: "default".to_string(),
until: Some(until),
};
let translated = translate_error(&err);
assert!(translated.contains("service=default"));
assert!(translated.contains("账号已被封禁"));
}
#[test]
fn translate_error_en_disable_service() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::DisableService {
service: "oidc".to_string(),
until: None,
};
let translated = translate_error(&err);
assert!(translated.contains("service=oidc"));
assert!(translated.contains("Account disabled"));
}
#[test]
fn translate_error_zh_not_safe() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::NotSafe {
reason: "MFA_TOTP_REQUIRED".to_string(),
};
assert_eq!(translate_error(&err), "未完成二次认证:MFA_TOTP_REQUIRED");
}
#[test]
fn translate_error_en_not_safe() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::NotSafe {
reason: "WEBAUTHN_REQUIRED".to_string(),
};
assert_eq!(
translate_error(&err),
"Second factor authentication required: WEBAUTHN_REQUIRED"
);
}
#[test]
fn translate_error_zh_invalid_state_transition() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::InvalidStateTransition {
from: "Active".to_string(),
to: "Closed".to_string(),
};
assert_eq!(translate_error(&err), "非法状态转换:Active -> Closed");
}
#[test]
fn translate_error_en_invalid_state_transition() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::InvalidStateTransition {
from: "Pending".to_string(),
to: "Active".to_string(),
};
assert_eq!(
translate_error(&err),
"Invalid state transition: Pending -> Active"
);
}
#[test]
fn translate_error_zh_sms_rate_limit_exceeded() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::SmsRateLimitExceeded {
window: "hourly".to_string(),
};
assert_eq!(translate_error(&err), "SMS 限速超出: hourly 窗口");
}
#[test]
fn translate_error_en_sms_rate_limit_exceeded() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::SmsRateLimitExceeded {
window: "daily".to_string(),
};
assert_eq!(
translate_error(&err),
"SMS rate limit exceeded: daily window"
);
}
#[test]
fn translate_error_zh_sms_verify_max_attempts() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::SmsVerifyMaxAttempts;
assert_eq!(translate_error(&err), "SMS 验证码尝试次数超限");
}
#[test]
fn translate_error_en_sms_verify_max_attempts() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::SmsVerifyMaxAttempts;
assert_eq!(
translate_error(&err),
"SMS verification max attempts exceeded"
);
}
#[test]
fn translate_error_zh_sms_code_not_found() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::SmsCodeNotFound;
assert_eq!(translate_error(&err), "SMS 验证码不存在");
}
#[test]
fn translate_error_en_sms_code_not_found() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::SmsCodeNotFound;
assert_eq!(translate_error(&err), "SMS verification code not found");
}
#[test]
fn translate_error_zh_sms_channel_recycled() {
let _guard = set_locale(GarrisonLocale::Zh);
let err = GarrisonError::SmsChannelRecycled;
assert_eq!(translate_error(&err), "SMS 通道已回收");
}
#[test]
fn translate_error_en_sms_channel_recycled() {
let _guard = set_locale(GarrisonLocale::En);
let err = GarrisonError::SmsChannelRecycled;
assert_eq!(translate_error(&err), "SMS channel recycled");
}
#[test]
fn fallback_display_new_variants() {
let until = chrono::DateTime::parse_from_rfc3339("2026-01-01T00:00:00Z")
.unwrap()
.with_timezone(&chrono::Utc);
let cases: Vec<(GarrisonError, String)> = vec![
(
GarrisonError::TokenRevoked("x".into()),
"Token 已吊销: x".to_string(),
),
(
GarrisonError::FirewallBlocked("x".into()),
"防火墙拦截: x".to_string(),
),
(
GarrisonError::DisableService {
service: "default".into(),
until: Some(until),
},
format!("账号已被封禁:service=default, until={:?}", Some(until)),
),
(
GarrisonError::DisableService {
service: "oidc".into(),
until: None,
},
"账号已被封禁:service=oidc, until=None".to_string(),
),
(
GarrisonError::NotSafe { reason: "r".into() },
"未完成二次认证:r".to_string(),
),
(
GarrisonError::InvalidStateTransition {
from: "A".into(),
to: "B".into(),
},
"非法状态转换:A -> B".to_string(),
),
(
GarrisonError::SmsRateLimitExceeded { window: "w".into() },
"SMS 限速超出: w 窗口".to_string(),
),
(
GarrisonError::SmsVerifyMaxAttempts,
"SMS 验证码尝试次数超限".to_string(),
),
(
GarrisonError::SmsCodeNotFound,
"SMS 验证码不存在".to_string(),
),
(
GarrisonError::SmsChannelRecycled,
"SMS 通道已回收".to_string(),
),
];
for (err, expected) in cases {
assert_eq!(fallback_display(&err), expected, "mismatch for {:?}", err);
}
}
#[test]
fn error_to_key_args_all_variants() {
let until = chrono::Utc::now();
let cases: Vec<GarrisonError> = vec![
GarrisonError::NotLogin("a".into()),
GarrisonError::NotPermission("a".into()),
GarrisonError::NotRole("a".into()),
GarrisonError::InvalidToken("a".into()),
GarrisonError::TokenRevoked("a".into()),
GarrisonError::ExpiredToken("a".into()),
GarrisonError::Dao("a".into()),
GarrisonError::Config("a".into()),
GarrisonError::Internal("a".into()),
GarrisonError::Session("a".into()),
GarrisonError::Annotation("a".into()),
GarrisonError::Context("a".into()),
GarrisonError::OAuth2("a".into()),
GarrisonError::Network("a".into()),
GarrisonError::InvalidParam("a".into()),
GarrisonError::NotImplemented("a".into()),
GarrisonError::FirewallBlocked("a".into()),
GarrisonError::DisableService {
service: "s".into(),
until: Some(until),
},
GarrisonError::NotSafe { reason: "r".into() },
GarrisonError::InvalidStateTransition {
from: "f".into(),
to: "t".into(),
},
GarrisonError::SmsRateLimitExceeded { window: "w".into() },
GarrisonError::SmsVerifyMaxAttempts,
GarrisonError::SmsCodeNotFound,
GarrisonError::SmsChannelRecycled,
GarrisonError::Exception(GarrisonException::new(-1, "msg")),
];
for err in cases {
let (key, _args) = error_to_key_args(&err);
assert!(!key.is_empty(), "key 不应为空: {:?}", err);
}
}
#[test]
fn get_bundle_en_returns_cached_instance() {
let b1 = get_bundle(GarrisonLocale::En);
let b2 = get_bundle(GarrisonLocale::En);
assert!(std::ptr::eq(b1, b2), "英文 bundle 应为同一缓存实例");
}
#[test]
fn translate_detail_known_key_returns_translation() {
let _guard = set_locale(GarrisonLocale::En);
let result = translate_detail("not-login", &[("detail", "test")]);
assert!(result.contains("test"), "应包含参数值: {}", result);
}
#[test]
fn translate_detail_unknown_key_returns_key() {
let _guard = set_locale(GarrisonLocale::En);
let result = translate_detail("nonexistent-key-xyz", &[]);
assert_eq!(result, "nonexistent-key-xyz");
}
#[test]
fn translate_detail_known_key_no_args() {
let _guard = set_locale(GarrisonLocale::Zh);
let result = translate_detail("sms-verify-max-attempts", &[]);
assert!(!result.is_empty());
assert_ne!(result, "sms-verify-max-attempts", "应返回翻译而非 key 本身");
}
#[cfg(feature = "i18n-icu")]
#[test]
fn icu_plural_category_en_one() {
let _guard = set_locale(GarrisonLocale::En);
let cat = icu_enhanced::plural_category(1);
assert_eq!(cat, icu_plurals::PluralCategory::One);
}
#[cfg(feature = "i18n-icu")]
#[test]
fn icu_plural_category_en_other() {
let _guard = set_locale(GarrisonLocale::En);
let cat = icu_enhanced::plural_category(2);
assert_eq!(cat, icu_plurals::PluralCategory::Other);
}
#[cfg(feature = "i18n-icu")]
#[test]
fn icu_format_number_en() {
let _guard = set_locale(GarrisonLocale::En);
let formatted = icu_enhanced::format_number_locale(1_000_000);
assert!(formatted.contains("1"), "应包含数字 1: {}", formatted);
}
#[cfg(feature = "i18n-icu")]
#[test]
fn icu_format_datetime_en() {
let _guard = set_locale(GarrisonLocale::En);
let dt = chrono::DateTime::parse_from_rfc3339("2026-01-01T00:00:00Z")
.unwrap()
.with_timezone(&chrono::Utc);
let formatted = icu_enhanced::format_datetime_locale(&dt);
assert!(!formatted.is_empty(), "日期格式化不应为空");
assert!(formatted.contains("2026"), "应包含年份: {}", formatted);
}
}