footing 0.1.21

Feature-gated foundations for Rust backend services
Documentation
use std::time::Duration;

use super::{
    MAX_SETTINGS_ISSUES, SettingsIssue, SettingsIssues, SettingsValidationError, human_duration,
};
use crate::result::{ClassifyError, ErrorKind};

#[cfg(any(
    feature = "http",
    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")]
    {
        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"));
}