use serde::{Deserialize, Serialize};
use super::cycle::CreditCycle;
use super::schedule::CreditSchedule;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreditConfig {
pub credit_limit: u64,
pub cycle: CreditCycle,
pub schedule: CreditSchedule,
pub alert_thresholds: Vec<u8>,
pub persist_history: bool,
}
impl Default for CreditConfig {
fn default() -> Self {
Self {
credit_limit: 10_000,
cycle: CreditCycle::Fixed { day_of_month: 1 },
schedule: CreditSchedule::default(),
alert_thresholds: vec![80, 90, 100],
persist_history: false,
}
}
}
impl CreditConfig {
pub fn validate(&self) -> Result<(), String> {
validate_thresholds(&self.alert_thresholds, "credit-alert-thresholds")
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CreditAlertConfig {
pub thresholds: Vec<u8>,
pub cooldown_seconds: u64,
}
impl CreditAlertConfig {
pub fn validate(&self) -> Result<(), String> {
validate_thresholds(&self.thresholds, "credit-alert-thresholds")
}
}
fn validate_thresholds(thresholds: &[u8], prefix: &str) -> Result<(), String> {
if thresholds.is_empty() {
return Err(format!("{}-empty::", prefix));
}
for (i, &t) in thresholds.iter().enumerate() {
if t > 100 {
return Err(format!("{}-range::{}::{}", prefix, i, t));
}
if i > 0 && t <= thresholds[i - 1] {
return Err(format!(
"{}-order::[{}]={}::[{}]={}",
prefix,
i,
t,
i - 1,
thresholds[i - 1]
));
}
}
Ok(())
}
impl Default for CreditAlertConfig {
fn default() -> Self {
Self {
thresholds: vec![80, 90, 100],
cooldown_seconds: 3600,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_credit_config_default_values() {
let config = CreditConfig::default();
assert_eq!(config.credit_limit, 10_000);
assert_eq!(config.cycle, CreditCycle::Fixed { day_of_month: 1 });
assert_eq!(config.schedule.default_weight(), 1);
assert_eq!(config.alert_thresholds, vec![80, 90, 100]);
assert!(!config.persist_history);
}
#[test]
fn test_validate_ok_with_boundary_values() {
let config = CreditConfig {
alert_thresholds: vec![0, 50, 100],
..CreditConfig::default()
};
assert!(config.validate().is_ok(), "0 与 100 均在合法范围");
}
#[test]
fn test_validate_empty_thresholds_err() {
let config = CreditConfig {
alert_thresholds: vec![],
..CreditConfig::default()
};
let err = config.validate().unwrap_err();
assert!(
err.contains("credit-alert-thresholds-empty"),
"实际错误: {}",
err
);
}
#[test]
fn test_validate_threshold_over_100_err() {
let config = CreditConfig {
alert_thresholds: vec![50, 101],
..CreditConfig::default()
};
let err = config.validate().unwrap_err();
assert!(
err.contains("credit-alert-thresholds-range") && err.contains("101"),
"实际错误: {}",
err
);
}
#[test]
fn test_validate_equal_thresholds_err() {
let config = CreditConfig {
alert_thresholds: vec![80, 80],
..CreditConfig::default()
};
let err = config.validate().unwrap_err();
assert!(
err.contains("credit-alert-thresholds-order"),
"实际错误: {}",
err
);
}
#[test]
fn test_validate_descending_thresholds_err() {
let config = CreditConfig {
alert_thresholds: vec![90, 80],
..CreditConfig::default()
};
let err = config.validate().unwrap_err();
assert!(
err.contains("credit-alert-thresholds-order"),
"实际错误: {}",
err
);
}
#[test]
fn test_validate_default_config_ok() {
assert!(CreditConfig::default().validate().is_ok());
}
#[test]
fn test_alert_config_validate_ok() {
let alert = CreditAlertConfig {
thresholds: vec![10, 50, 100],
cooldown_seconds: 60,
};
assert!(alert.validate().is_ok());
}
#[test]
fn test_alert_config_validate_empty_err() {
let alert = CreditAlertConfig {
thresholds: vec![],
cooldown_seconds: 60,
};
let err = alert.validate().unwrap_err();
assert!(
err.contains("credit-alert-thresholds-empty"),
"实际错误: {}",
err
);
}
#[test]
fn test_alert_config_validate_range_and_order_err() {
let over = CreditAlertConfig {
thresholds: vec![50, 101],
cooldown_seconds: 60,
};
assert!(over
.validate()
.unwrap_err()
.contains("credit-alert-thresholds-range"));
let unsorted = CreditAlertConfig {
thresholds: vec![90, 80],
cooldown_seconds: 60,
};
assert!(unsorted
.validate()
.unwrap_err()
.contains("credit-alert-thresholds-order"));
}
#[test]
fn test_credit_config_serde_roundtrip() {
let mut schedule = CreditSchedule::with_default(2).unwrap();
schedule.insert("sms", 5).unwrap();
let config = CreditConfig {
credit_limit: u64::MAX,
cycle: CreditCycle::Rolling { days: 7 },
schedule,
alert_thresholds: vec![10, 20],
persist_history: true,
};
let serialized = toml::to_string(&config).unwrap();
let deserialized: CreditConfig = toml::from_str(&serialized).unwrap();
assert_eq!(deserialized.credit_limit, u64::MAX);
assert_eq!(deserialized.cycle, CreditCycle::Rolling { days: 7 });
assert_eq!(deserialized.schedule.weight_for("sms"), 5);
assert_eq!(deserialized.alert_thresholds, vec![10, 20]);
assert!(deserialized.persist_history);
}
#[test]
fn test_credit_alert_config_default_values() {
let alert = CreditAlertConfig::default();
assert_eq!(alert.thresholds, vec![80, 90, 100]);
assert_eq!(alert.cooldown_seconds, 3600);
}
#[test]
fn test_credit_alert_config_serde_roundtrip() {
let alert = CreditAlertConfig {
thresholds: vec![50],
cooldown_seconds: 0,
};
let serialized = toml::to_string(&alert).unwrap();
let deserialized: CreditAlertConfig = toml::from_str(&serialized).unwrap();
assert_eq!(deserialized.thresholds, vec![50]);
assert_eq!(deserialized.cooldown_seconds, 0);
}
#[test]
fn test_credit_config_debug() {
let debug = format!("{:?}", CreditConfig::default());
assert!(debug.contains("CreditConfig"), "实际: {}", debug);
}
#[test]
fn test_credit_alert_config_debug() {
let debug = format!("{:?}", CreditAlertConfig::default());
assert!(debug.contains("CreditAlertConfig"), "实际: {}", debug);
}
}