footing 0.1.6

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};

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"));
}