horologe 2.0.0

Earth has 4 corner simultaneous 4-day time cube within single rotation
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// SPDX-License-Identifier: MIT
// Copyright (C) 2025 Michael Dippery <michael@monkey-robot.com>

//! Utilities for tests involving time.

use crate::{Clock, DateTime, Error, Utc};

#[cfg(doc)]
use chrono::ParseError;

/// A clock that always returns the same time.
///
/// This is useful for "freezing time" in unit tests. In your tests, call
/// [`FrozenClock::default()`] to create a clock that always returns the
/// time specified in [`FrozenClock::default_datetime`]. This clock's notion
/// of "now" (as returned by [`FrozenClock::now()`]) is always the same and
/// always in the past.
#[derive(Debug)]
pub struct FrozenClock {
    datetime: DateTime<Utc>,
}

impl FrozenClock {
    const DEFAULT_DATETIME: &'static str = "2025-05-23T10:13:00-07:00";

    /// The default datetime, used when constructing default frozen clocks.
    ///
    /// This date is guaranteed to always be in the past.
    pub fn default_datetime() -> DateTime<Utc> {
        DateTime::parse_from_rfc3339(Self::DEFAULT_DATETIME.as_ref())
            .expect(&format!("invalid default date: {}", Self::DEFAULT_DATETIME))
            .with_timezone(&Utc)
    }

    /// Creates a new frozen clock that always returns the given `datetime`
    /// as "now".
    pub fn new(datetime: DateTime<Utc>) -> Self {
        FrozenClock { datetime }
    }
}

impl TryFrom<String> for FrozenClock {
    type Error = Error;

    /// Creates a new frozen clock that always returns the given `datetime`
    /// as "now".
    ///
    /// Returns a `Result` wrapping a chrono [`ParseError`] if `datetime`
    /// cannot be parsed.
    fn try_from(value: String) -> Result<Self, Self::Error> {
        Self::try_from(value.as_str())
    }
}

impl TryFrom<&str> for FrozenClock {
    type Error = Error;

    /// Creates a new frozen clock that always returns the given `datetime`
    /// as "now".
    ///
    /// Returns a `Result` wrapping a chrono [`ParseError`] if `datetime`
    /// cannot be parsed.
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        let datetime = DateTime::parse_from_rfc3339(value)?.with_timezone(&Utc);
        Ok(Self::new(datetime))
    }
}

impl Clock for FrozenClock {
    fn now(&self) -> DateTime<Utc> {
        self.datetime
    }
}

impl Default for FrozenClock {
    /// Always returns a datetime specified by [`FrozenClock::default_datetime`]
    /// for "now".
    fn default() -> Self {
        Self::new(Self::default_datetime())
    }
}

#[cfg(test)]
mod tests {
    use super::FrozenClock;
    use crate::{Clock, Error, SystemClock};
    use chrono::{Datelike, Timelike};

    #[test]
    fn it_parses_a_datetime_string() -> Result<(), Error> {
        let s = "2025-12-25T12:01:02-08:00";
        let dt = FrozenClock::try_from(String::from(s))?.now();
        assert_eq!(dt.month(), 12);
        assert_eq!(dt.day(), 25);
        assert_eq!(dt.year(), 2025);
        assert_eq!(dt.hour(), 20);
        assert_eq!(dt.minute(), 1);
        assert_eq!(dt.second(), 2);
        Ok(())
    }

    #[test]
    fn it_parses_a_datetime_str() -> Result<(), Error> {
        let s = "2025-12-25T12:01:02-08:00";
        let dt = FrozenClock::try_from(s)?.now();
        assert_eq!(dt.month(), 12);
        assert_eq!(dt.day(), 25);
        assert_eq!(dt.year(), 2025);
        assert_eq!(dt.hour(), 20);
        assert_eq!(dt.minute(), 1);
        assert_eq!(dt.second(), 2);
        Ok(())
    }

    #[test]
    fn it_returns_an_error_if_there_is_an_invalid_string() {
        let s = "2025-12-32T12:01:02-08:00";
        let c = FrozenClock::try_from(s);
        assert!(c.is_err());
    }

    #[test]
    fn it_returns_a_default_date_in_the_past() {
        let now = SystemClock::default().now();
        let dt = FrozenClock::default().now();
        assert!(dt < now);
    }
}