use std::time::Duration;
use super::{
MAX_SETTINGS_ISSUES, SettingsIssue, SettingsIssues, SettingsValidationError, human_duration,
};
use crate::result::{ClassifyError, ErrorKind};
#[cfg(any(
feature = "http-stack",
feature = "worker",
feature = "postgres",
feature = "sqlite",
feature = "tls"
))]
#[test]
fn empty_settings_use_rust_defaults_and_reject_unknown_fields() {
fn check<T: Default + serde::Serialize + serde::de::DeserializeOwned>() {
let empty: T = serde_json::from_str("{}").unwrap();
let expected = serde_json::to_value(T::default()).unwrap();
assert_eq!(
serde_json::to_value(empty).unwrap(),
expected,
"{}",
std::any::type_name::<T>()
);
let round_trip: T = serde_json::from_value(expected.clone()).unwrap();
assert_eq!(serde_json::to_value(round_trip).unwrap(), expected);
assert!(serde_json::from_str::<T>(r#"{"unknown_field": true}"#).is_err());
}
#[cfg(feature = "http-stack")]
{
use crate::http::*;
check::<HttpMiddlewareSettings>();
check::<HttpRequestPolicySettings>();
check::<HttpRouteRuleSettings>();
check::<HttpRateLimitSettings>();
check::<HttpIdempotencySettings>();
check::<CorsSettings>();
check::<ForwardedHeadersSettings>();
check::<SecurityHeadersSettings>();
check::<StrictTransportSecuritySettings>();
}
#[cfg(feature = "worker")]
{
check::<crate::worker::WorkerSettings>();
check::<crate::worker::BackoffSettings>();
check::<crate::worker::OutboxWorkerSettings>();
}
#[cfg(feature = "postgres")]
{
check::<crate::db::postgres::PostgresPoolSettings>();
check::<crate::db::postgres::PostgresStartupRetrySettings>();
assert!(
serde_json::from_str::<crate::db::postgres::PostgresBootstrapSettings>("{}").is_err()
);
}
#[cfg(feature = "sqlite")]
{
check::<crate::db::sqlite::SqlitePoolSettings>();
assert!(serde_json::from_str::<crate::db::sqlite::SqliteConnectionSettings>("{}").is_err());
assert!(serde_json::from_str::<crate::db::sqlite::SqliteBootstrapSettings>("{}").is_err());
}
#[cfg(feature = "tls")]
check::<crate::tls::TlsTrustSettings>();
}
struct AppConfig {
host: String,
port: u16,
}
impl AppConfig {
fn validate(&self) -> Result<(), super::SettingsValidationError> {
let mut issues = SettingsIssues::new();
issues.require_non_empty("server.host", &self.host);
issues.require(self.port > 0, "server.port", "must be greater than zero");
issues.into_result()
}
fn build(&self) -> Result<String, super::SettingsValidationError> {
self.validate()?;
Ok(format!("{}:{}", self.host, self.port))
}
}
#[test]
fn settings_issues_merge_nested_validation_errors() {
let mut collector = SettingsIssues::new();
collector.require_non_empty("server.host", "");
collector.extend_result(
AppConfig {
host: String::new(),
port: 0,
}
.validate(),
);
let error = collector
.into_result()
.expect_err("collector should contain validation issues");
let paths = error
.issues()
.iter()
.map(|issue| issue.path())
.collect::<Vec<_>>();
assert!(paths.contains(&"server.host"));
assert!(paths.contains(&"server.port"));
assert_eq!(error.error_kind(), ErrorKind::Validation);
assert_eq!(error.error_code(), "settings_invalid");
}
#[test]
fn settings_issue_uses_stable_fallbacks_for_empty_operator_text() {
let issue = SettingsIssue::new(" ", "");
assert_eq!(issue.path(), "settings");
assert_eq!(issue.message(), "are invalid");
}
#[test]
fn settings_issues_report_when_the_bounded_collection_is_truncated() {
let mut issues = SettingsIssues::new();
for index in 0..=MAX_SETTINGS_ISSUES {
issues.push(format!("field.{index}"), "is invalid");
}
assert_eq!(issues.len(), MAX_SETTINGS_ISSUES);
assert!(issues.is_truncated());
let message = issues.into_result().unwrap_err().to_string();
assert!(message.contains("additional issues omitted"));
}
#[test]
fn settings_validation_error_normalizes_an_empty_issue_collection() {
let error = SettingsValidationError::new(SettingsIssues::new());
assert_eq!(error.issues().len(), 1);
assert_eq!(error.issues()[0].path(), "settings");
assert_eq!(error.issues()[0].message(), "are invalid");
}
#[test]
fn human_duration_accepts_compact_duration_strings() {
assert_eq!(
human_duration::parse("1h30m").expect("duration should parse"),
Duration::from_secs(90 * 60)
);
assert_eq!(
human_duration::parse("500ms").expect("duration should parse"),
Duration::from_millis(500)
);
assert_eq!(
human_duration::parse("1µs").expect("duration should parse"),
Duration::from_micros(1)
);
assert_eq!(
human_duration::parse("2w 3d 4h").expect("duration should parse"),
Duration::from_secs((14 + 3) * 24 * 60 * 60 + 4 * 60 * 60)
);
}
#[test]
fn human_duration_rejects_ambiguous_values() {
assert!(human_duration::parse("").is_err());
assert!(human_duration::parse("5").is_err());
assert!(human_duration::parse("1mo").is_err());
assert_eq!(
human_duration::parse("1msec"),
Err(human_duration::ParseDurationError::InvalidUnit)
);
assert!(human_duration::parse("m").is_err());
}
#[test]
fn human_duration_errors_have_stable_classification() {
let error = human_duration::parse("1mo").expect_err("unit should be invalid");
let descriptor = error.error_descriptor();
assert_eq!(descriptor.kind(), ErrorKind::Validation);
assert_eq!(descriptor.code().as_str(), "duration_invalid_unit");
}
#[test]
fn human_duration_formats_using_largest_exact_unit() {
assert_eq!(human_duration::format(Duration::from_secs(60 * 60)), "1h");
assert_eq!(human_duration::format(Duration::from_millis(500)), "500ms");
assert_eq!(human_duration::format(Duration::from_nanos(1)), "1ns");
}
#[test]
fn human_duration_option_supports_null_and_strings() {
#[derive(serde::Deserialize, serde::Serialize)]
struct Config {
#[serde(default, with = "human_duration::option")]
value: Option<Duration>,
}
let parsed: Config = serde_json::from_str(r#"{ "value": "5m" }"#).unwrap();
assert_eq!(parsed.value, Some(Duration::from_secs(300)));
let parsed: Config = serde_json::from_str(r#"{ "value": null }"#).unwrap();
assert_eq!(parsed.value, None);
assert_eq!(
serde_json::to_value(Config {
value: Some(Duration::from_secs(30))
})
.unwrap(),
serde_json::json!({ "value": "30s" })
);
}
#[test]
fn settings_build_validates_before_mapping() {
let config = AppConfig {
host: "127.0.0.1".to_owned(),
port: 8080,
};
assert_eq!(config.build().unwrap(), "127.0.0.1:8080");
let config = AppConfig {
host: String::new(),
port: 0,
};
let error = config.build().unwrap_err();
assert_eq!(error.issues().len(), 2);
assert!(error.to_string().contains("server.host"));
}