duration-human 0.1.10

Duration wrapper to interact with humans
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use crate::{DurationError, DurationHuman};

#[test]
fn roundtrip() {
    let duration = format!(
        "{:#}",
        DurationHuman::try_from("2years 1 week 3days 5h 6min 10s").unwrap()
    );
    assert_eq!(duration, format!("2 years 1 week 3 days 5h 6min 10s"));

    let duration = format!("{:#}", DurationHuman::try_from(duration.as_str()).unwrap());
    assert_eq!(duration, format!("2 years 1 week 3 days 5h 6min 10s"));
}

#[test]
fn ignore_blanks_in_input() -> Result<(), DurationError> {
    let duration = DurationHuman::try_from("2year 1 week 3day 5h 6min 10s")?;
    assert_eq!(
        format!("{duration:#}"),
        format!("2 years 1 week 3 days 5h 6min 10s")
    );
    Ok(())
}

#[test]
fn max_ns() {
    let duration = DurationHuman::from(u64::MAX);
    assert_eq!(
        format!("{duration:#}"),
        format!("5 centuries 84 years 6 months 2 weeks 1 day 8h 34min 33s 709ms 551μs 615ns")
    );
}

#[test]
fn max() -> Result<(), DurationError> {
    let duration = DurationHuman::try_from(
        "5 centuries 84 years 6 months 2 weeks 1 day 8h 34min 33s 709ms 551μs 615ns",
    )?;
    let pretty = format!("{duration:#}");
    let duration_from_pretty = DurationHuman::try_from(pretty.as_str())?;
    assert_eq!(duration, duration_from_pretty);
    Ok(())
}

mod errors {
    use crate::{DurationError, DurationHuman};

    #[test]
    fn overflow() {
        let duration = DurationHuman::try_from("584 year 5 months 7 weeks 7 days 49h");
        let is_err = duration.is_err();
        assert!(is_err);
        if let Err(err) = duration {
            match err {
                DurationError::IntegerOverflowAt { duration } => {
                    assert_eq!(duration, "7 weeks".to_string());
                }
                err => assert!(!is_err, "Did not expect the error: '{err}'"),
            }
        }
    }

    #[test]
    fn overflow_ms() {
        let duration = DurationHuman::try_from("18446744073709551615ms");
        let is_err = duration.is_err();
        assert!(is_err);
        if let Err(err) = duration {
            match err {
                DurationError::IntegerOverflowAt { duration } => assert!(!duration.is_empty()),
                err => assert!(!is_err, "Did not expect the error: '{err}'"),
            }
        }
    }

    #[test]
    fn syntax_error() {
        let result = DurationHuman::try_from("2year 1 week 3dya 5h 6min 10s");
        let contrived = result.iter().count();
        match result {
            Err(DurationError::InvalidSyntax) => (),
            Err(err) => assert_eq!(contrived, 3, "Did not expect this error {err}"),
            Ok(duration) => assert_eq!(
                contrived, 3,
                "Did not expect a valid duration {:#}",
                duration
            ),
        }
    }
}