642 lines
21 KiB
Rust
642 lines
21 KiB
Rust
//! Time utilities for shepherdd
|
|
//!
|
|
//! Provides both monotonic time (for countdown enforcement) and
|
|
//! wall-clock time (for availability windows).
|
|
//!
|
|
//! # Mock Time for Development
|
|
//!
|
|
//! In debug builds, the `SHEPHERD_MOCK_TIME` environment variable can be set
|
|
//! to override the system time for all time-sensitive operations. This is useful
|
|
//! for testing availability windows and time-based policies.
|
|
//!
|
|
//! Format: `YYYY-MM-DD HH:MM:SS` (e.g., `2025-12-25 14:30:00`)
|
|
//!
|
|
//! Example:
|
|
//! ```bash
|
|
//! SHEPHERD_MOCK_TIME="2025-12-25 14:30:00" ./run-dev
|
|
//! ```
|
|
|
|
use chrono::{DateTime, Datelike, Local, NaiveDateTime, NaiveTime, TimeZone, Timelike, Weekday};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::sync::OnceLock;
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// Environment variable name for mock time (debug builds only)
|
|
pub const MOCK_TIME_ENV_VAR: &str = "SHEPHERD_MOCK_TIME";
|
|
|
|
/// Cached mock time offset from the real time when the process started.
|
|
/// This allows mock time to advance naturally.
|
|
static MOCK_TIME_OFFSET: OnceLock<Option<chrono::Duration>> = OnceLock::new();
|
|
|
|
/// Initialize the mock time offset based on the environment variable.
|
|
/// Returns the offset between mock time and real time at process start.
|
|
#[allow(clippy::disallowed_methods)] // This is the internal implementation that wraps Local::now()
|
|
fn get_mock_time_offset() -> Option<chrono::Duration> {
|
|
*MOCK_TIME_OFFSET.get_or_init(|| {
|
|
#[cfg(debug_assertions)]
|
|
{
|
|
if let Ok(mock_time_str) = std::env::var(MOCK_TIME_ENV_VAR) {
|
|
// Parse the mock time string
|
|
if let Ok(naive_dt) =
|
|
NaiveDateTime::parse_from_str(&mock_time_str, "%Y-%m-%d %H:%M:%S")
|
|
{
|
|
if let Some(mock_dt) = Local.from_local_datetime(&naive_dt).single() {
|
|
let real_now = chrono::Local::now();
|
|
let offset = mock_dt.signed_duration_since(real_now);
|
|
tracing::info!(
|
|
mock_time = %mock_time_str,
|
|
offset_secs = offset.num_seconds(),
|
|
"Mock time enabled"
|
|
);
|
|
return Some(offset);
|
|
} else {
|
|
tracing::warn!(
|
|
mock_time = %mock_time_str,
|
|
"Failed to convert mock time to local timezone"
|
|
);
|
|
}
|
|
} else {
|
|
tracing::warn!(
|
|
mock_time = %mock_time_str,
|
|
expected_format = "%Y-%m-%d %H:%M:%S",
|
|
"Invalid mock time format"
|
|
);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
#[cfg(not(debug_assertions))]
|
|
{
|
|
None
|
|
}
|
|
})
|
|
}
|
|
|
|
/// Returns whether mock time is currently active.
|
|
pub fn is_mock_time_active() -> bool {
|
|
get_mock_time_offset().is_some()
|
|
}
|
|
|
|
/// Get the current local time, respecting mock time settings in debug builds.
|
|
///
|
|
/// In release builds, this always returns the real system time.
|
|
/// In debug builds, if `SHEPHERD_MOCK_TIME` is set, this returns a time
|
|
/// that advances from the mock time at the same rate as real time.
|
|
#[allow(clippy::disallowed_methods)] // This is the wrapper that provides mock time support
|
|
pub fn now() -> DateTime<Local> {
|
|
let real_now = chrono::Local::now();
|
|
|
|
if let Some(offset) = get_mock_time_offset() {
|
|
real_now + offset
|
|
} else {
|
|
real_now
|
|
}
|
|
}
|
|
|
|
/// Format a DateTime for display in the HUD clock.
|
|
/// Always uses 12-hour format with AM/PM, ignoring system locale.
|
|
pub fn format_clock_time(dt: &DateTime<Local>) -> String {
|
|
dt.format("%l:%M %p").to_string()
|
|
}
|
|
|
|
/// Format a DateTime for display with full date and time.
|
|
pub fn format_datetime_full(dt: &DateTime<Local>) -> String {
|
|
dt.format("%Y-%m-%d %l:%M:%S %p").to_string()
|
|
}
|
|
|
|
/// Represents a point in monotonic time for countdown enforcement.
|
|
/// This is immune to wall-clock changes.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub struct MonotonicInstant(Instant);
|
|
|
|
impl MonotonicInstant {
|
|
pub fn now() -> Self {
|
|
Self(Instant::now())
|
|
}
|
|
|
|
pub fn elapsed(&self) -> Duration {
|
|
self.0.elapsed()
|
|
}
|
|
|
|
pub fn duration_since(&self, earlier: MonotonicInstant) -> Duration {
|
|
self.0.duration_since(earlier.0)
|
|
}
|
|
|
|
pub fn checked_add(&self, duration: Duration) -> Option<MonotonicInstant> {
|
|
self.0.checked_add(duration).map(MonotonicInstant)
|
|
}
|
|
|
|
/// Returns duration until `self`, or zero if `self` is in the past
|
|
pub fn saturating_duration_until(&self, from: MonotonicInstant) -> Duration {
|
|
if self.0 > from.0 {
|
|
self.0.duration_since(from.0)
|
|
} else {
|
|
Duration::ZERO
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::ops::Add<Duration> for MonotonicInstant {
|
|
type Output = MonotonicInstant;
|
|
|
|
fn add(self, rhs: Duration) -> Self::Output {
|
|
MonotonicInstant(self.0 + rhs)
|
|
}
|
|
}
|
|
|
|
/// Wall-clock time for availability windows
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct WallClock {
|
|
pub hour: u8,
|
|
pub minute: u8,
|
|
}
|
|
|
|
impl WallClock {
|
|
pub fn new(hour: u8, minute: u8) -> Option<Self> {
|
|
if hour < 24 && minute < 60 {
|
|
Some(Self { hour, minute })
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn to_naive_time(self) -> NaiveTime {
|
|
NaiveTime::from_hms_opt(self.hour as u32, self.minute as u32, 0).unwrap()
|
|
}
|
|
|
|
pub fn from_naive_time(time: NaiveTime) -> Self {
|
|
Self {
|
|
hour: time.hour() as u8,
|
|
minute: time.minute() as u8,
|
|
}
|
|
}
|
|
|
|
/// Returns seconds since midnight
|
|
pub fn as_seconds_from_midnight(&self) -> u32 {
|
|
(self.hour as u32) * 3600 + (self.minute as u32) * 60
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for WallClock {
|
|
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
|
Some(self.cmp(other))
|
|
}
|
|
}
|
|
|
|
impl Ord for WallClock {
|
|
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
|
self.as_seconds_from_midnight()
|
|
.cmp(&other.as_seconds_from_midnight())
|
|
}
|
|
}
|
|
|
|
/// Days of the week mask
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
|
|
pub struct DaysOfWeek(u8);
|
|
|
|
impl DaysOfWeek {
|
|
pub const MONDAY: u8 = 1 << 0;
|
|
pub const TUESDAY: u8 = 1 << 1;
|
|
pub const WEDNESDAY: u8 = 1 << 2;
|
|
pub const THURSDAY: u8 = 1 << 3;
|
|
pub const FRIDAY: u8 = 1 << 4;
|
|
pub const SATURDAY: u8 = 1 << 5;
|
|
pub const SUNDAY: u8 = 1 << 6;
|
|
|
|
pub const WEEKDAYS: DaysOfWeek =
|
|
DaysOfWeek(Self::MONDAY | Self::TUESDAY | Self::WEDNESDAY | Self::THURSDAY | Self::FRIDAY);
|
|
pub const WEEKENDS: DaysOfWeek = DaysOfWeek(Self::SATURDAY | Self::SUNDAY);
|
|
pub const ALL_DAYS: DaysOfWeek = DaysOfWeek(0x7F);
|
|
pub const NONE: DaysOfWeek = DaysOfWeek(0);
|
|
|
|
pub fn new(mask: u8) -> Self {
|
|
Self(mask & 0x7F)
|
|
}
|
|
|
|
pub fn contains(&self, weekday: Weekday) -> bool {
|
|
let bit = match weekday {
|
|
Weekday::Mon => Self::MONDAY,
|
|
Weekday::Tue => Self::TUESDAY,
|
|
Weekday::Wed => Self::WEDNESDAY,
|
|
Weekday::Thu => Self::THURSDAY,
|
|
Weekday::Fri => Self::FRIDAY,
|
|
Weekday::Sat => Self::SATURDAY,
|
|
Weekday::Sun => Self::SUNDAY,
|
|
};
|
|
(self.0 & bit) != 0
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.0 == 0
|
|
}
|
|
}
|
|
|
|
impl std::ops::BitOr for DaysOfWeek {
|
|
type Output = Self;
|
|
|
|
fn bitor(self, rhs: Self) -> Self::Output {
|
|
Self(self.0 | rhs.0)
|
|
}
|
|
}
|
|
|
|
/// A time window during which an entry is available
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct TimeWindow {
|
|
pub days: DaysOfWeek,
|
|
pub start: WallClock,
|
|
pub end: WallClock,
|
|
}
|
|
|
|
impl TimeWindow {
|
|
pub fn new(days: DaysOfWeek, start: WallClock, end: WallClock) -> Self {
|
|
Self { days, start, end }
|
|
}
|
|
|
|
/// Check if the given local datetime falls within this window
|
|
pub fn contains(&self, dt: &DateTime<Local>) -> bool {
|
|
let weekday = dt.weekday();
|
|
if !self.days.contains(weekday) {
|
|
return false;
|
|
}
|
|
|
|
let time = WallClock::from_naive_time(dt.time());
|
|
|
|
// Handle windows that don't cross midnight
|
|
if self.start <= self.end {
|
|
time >= self.start && time < self.end
|
|
} else {
|
|
// Window crosses midnight (e.g., 22:00 - 02:00)
|
|
time >= self.start || time < self.end
|
|
}
|
|
}
|
|
|
|
/// Calculate duration remaining in this window from the given time
|
|
pub fn remaining_duration(&self, dt: &DateTime<Local>) -> Option<Duration> {
|
|
if !self.contains(dt) {
|
|
return None;
|
|
}
|
|
|
|
let now_time = WallClock::from_naive_time(dt.time());
|
|
let now_secs = now_time.as_seconds_from_midnight();
|
|
let end_secs = self.end.as_seconds_from_midnight();
|
|
|
|
let remaining_secs = if self.start <= self.end {
|
|
// Normal window
|
|
end_secs.saturating_sub(now_secs)
|
|
} else {
|
|
// Cross-midnight window
|
|
if now_secs >= self.start.as_seconds_from_midnight() {
|
|
// We're in the evening portion, count until midnight then add morning
|
|
(86400 - now_secs) + end_secs
|
|
} else {
|
|
// We're in the morning portion
|
|
end_secs.saturating_sub(now_secs)
|
|
}
|
|
};
|
|
|
|
Some(Duration::from_secs(remaining_secs as u64))
|
|
}
|
|
}
|
|
|
|
/// Helper to format durations in human-readable form
|
|
pub fn format_duration(d: Duration) -> String {
|
|
let total_secs = d.as_secs();
|
|
let hours = total_secs / 3600;
|
|
let minutes = (total_secs % 3600) / 60;
|
|
let seconds = total_secs % 60;
|
|
|
|
if hours > 0 {
|
|
format!("{}h {}m {}s", hours, minutes, seconds)
|
|
} else if minutes > 0 {
|
|
format!("{}m {}s", minutes, seconds)
|
|
} else {
|
|
format!("{}s", seconds)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use chrono::TimeZone;
|
|
|
|
#[test]
|
|
fn test_wall_clock_ordering() {
|
|
let morning = WallClock::new(8, 0).unwrap();
|
|
let noon = WallClock::new(12, 0).unwrap();
|
|
let evening = WallClock::new(18, 30).unwrap();
|
|
|
|
assert!(morning < noon);
|
|
assert!(noon < evening);
|
|
assert!(morning < evening);
|
|
}
|
|
|
|
#[test]
|
|
fn test_days_of_week() {
|
|
let weekdays = DaysOfWeek::WEEKDAYS;
|
|
assert!(weekdays.contains(Weekday::Mon));
|
|
assert!(weekdays.contains(Weekday::Fri));
|
|
assert!(!weekdays.contains(Weekday::Sat));
|
|
assert!(!weekdays.contains(Weekday::Sun));
|
|
|
|
let weekends = DaysOfWeek::WEEKENDS;
|
|
assert!(!weekends.contains(Weekday::Mon));
|
|
assert!(weekends.contains(Weekday::Sat));
|
|
assert!(weekends.contains(Weekday::Sun));
|
|
}
|
|
|
|
#[test]
|
|
fn test_time_window_contains() {
|
|
let window = TimeWindow::new(
|
|
DaysOfWeek::WEEKDAYS,
|
|
WallClock::new(14, 0).unwrap(), // 2 PM
|
|
WallClock::new(18, 0).unwrap(), // 6 PM
|
|
);
|
|
|
|
// Monday at 3 PM - should be in window
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 29, 15, 0, 0).unwrap(); // Monday
|
|
assert!(window.contains(&dt));
|
|
|
|
// Monday at 10 AM - outside window
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 29, 10, 0, 0).unwrap();
|
|
assert!(!window.contains(&dt));
|
|
|
|
// Saturday at 3 PM - wrong day
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 27, 15, 0, 0).unwrap();
|
|
assert!(!window.contains(&dt));
|
|
}
|
|
|
|
#[test]
|
|
fn test_time_window_remaining() {
|
|
let window = TimeWindow::new(
|
|
DaysOfWeek::ALL_DAYS,
|
|
WallClock::new(14, 0).unwrap(),
|
|
WallClock::new(18, 0).unwrap(),
|
|
);
|
|
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 26, 15, 0, 0).unwrap(); // 3 PM
|
|
let remaining = window.remaining_duration(&dt).unwrap();
|
|
assert_eq!(remaining, Duration::from_secs(3 * 3600)); // 3 hours
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_duration() {
|
|
assert_eq!(format_duration(Duration::from_secs(30)), "30s");
|
|
assert_eq!(format_duration(Duration::from_secs(90)), "1m 30s");
|
|
assert_eq!(format_duration(Duration::from_secs(3661)), "1h 1m 1s");
|
|
}
|
|
|
|
#[test]
|
|
fn test_monotonic_instant() {
|
|
let t1 = MonotonicInstant::now();
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
let t2 = MonotonicInstant::now();
|
|
|
|
assert!(t2 > t1);
|
|
assert!(t2.duration_since(t1) >= Duration::from_millis(10));
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_clock_time() {
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 25, 14, 30, 45).unwrap();
|
|
assert_eq!(format_clock_time(&dt), " 2:30 PM");
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_datetime_full() {
|
|
let dt = Local.with_ymd_and_hms(2025, 12, 25, 14, 30, 45).unwrap();
|
|
assert_eq!(format_datetime_full(&dt), "2025-12-25 2:30:45 PM");
|
|
}
|
|
|
|
#[test]
|
|
fn test_now_returns_time() {
|
|
// Basic test that now() returns a valid time
|
|
let t = now();
|
|
// Should be a reasonable year (after 2020, before 2100)
|
|
assert!(t.year() >= 2020);
|
|
assert!(t.year() <= 2100);
|
|
}
|
|
|
|
#[test]
|
|
fn test_mock_time_env_var_name() {
|
|
// Verify the environment variable name is correct
|
|
assert_eq!(MOCK_TIME_ENV_VAR, "SHEPHERD_MOCK_TIME");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_mock_time_format() {
|
|
// Test that the expected format parses correctly
|
|
let valid_formats = [
|
|
"2025-12-25 14:30:00",
|
|
"2025-01-01 00:00:00",
|
|
"2025-12-31 23:59:59",
|
|
"2020-06-15 12:00:00",
|
|
];
|
|
|
|
for format_str in &valid_formats {
|
|
let result = NaiveDateTime::parse_from_str(format_str, "%Y-%m-%d %H:%M:%S");
|
|
assert!(
|
|
result.is_ok(),
|
|
"Expected '{}' to parse successfully, got {:?}",
|
|
format_str,
|
|
result
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_mock_time_invalid_formats() {
|
|
// Test that invalid formats are rejected
|
|
let invalid_formats = [
|
|
"2025-12-25", // Missing time
|
|
"14:30:00", // Missing date
|
|
"2025/12/25 14:30:00", // Wrong date separator
|
|
"2025-12-25T14:30:00", // ISO format (not supported)
|
|
"Dec 25, 2025 14:30", // Wrong format
|
|
"25-12-2025 14:30:00", // Wrong date order
|
|
"", // Empty string
|
|
"not a date", // Invalid string
|
|
];
|
|
|
|
for format_str in &invalid_formats {
|
|
let result = NaiveDateTime::parse_from_str(format_str, "%Y-%m-%d %H:%M:%S");
|
|
assert!(
|
|
result.is_err(),
|
|
"Expected '{}' to fail parsing, but it succeeded",
|
|
format_str
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::disallowed_methods)] // Testing the offset calculation requires real time
|
|
fn test_mock_time_offset_calculation() {
|
|
// Test that the offset calculation works correctly
|
|
let mock_time_str = "2025-12-25 14:30:00";
|
|
let naive_dt = NaiveDateTime::parse_from_str(mock_time_str, "%Y-%m-%d %H:%M:%S").unwrap();
|
|
let mock_dt = Local.from_local_datetime(&naive_dt).single().unwrap();
|
|
let real_now = chrono::Local::now();
|
|
|
|
let offset = mock_dt.signed_duration_since(real_now);
|
|
|
|
// The offset should be applied correctly
|
|
let simulated_now = real_now + offset;
|
|
|
|
// The simulated time should be very close to the mock time
|
|
// (within a second, accounting for test execution time)
|
|
let diff = (simulated_now - mock_dt).num_seconds().abs();
|
|
assert!(
|
|
diff <= 1,
|
|
"Expected simulated time to be within 1 second of mock time, got {} seconds difference",
|
|
diff
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
#[allow(clippy::disallowed_methods)] // Testing time advancement requires real time
|
|
fn test_mock_time_advances_with_real_time() {
|
|
// Test that mock time advances at the same rate as real time
|
|
// This tests the concept, not the actual implementation (since OnceLock is static)
|
|
|
|
let mock_time_str = "2025-12-25 14:30:00";
|
|
let naive_dt = NaiveDateTime::parse_from_str(mock_time_str, "%Y-%m-%d %H:%M:%S").unwrap();
|
|
let mock_dt = Local.from_local_datetime(&naive_dt).single().unwrap();
|
|
|
|
let real_t1 = chrono::Local::now();
|
|
let offset = mock_dt.signed_duration_since(real_t1);
|
|
|
|
// Simulate time passing
|
|
std::thread::sleep(Duration::from_millis(100));
|
|
|
|
let real_t2 = chrono::Local::now();
|
|
let simulated_t1 = real_t1 + offset;
|
|
let simulated_t2 = real_t2 + offset;
|
|
|
|
// The simulated times should have advanced by the same amount as real times
|
|
let real_elapsed = real_t2.signed_duration_since(real_t1);
|
|
let simulated_elapsed = simulated_t2.signed_duration_since(simulated_t1);
|
|
|
|
assert_eq!(
|
|
real_elapsed.num_milliseconds(),
|
|
simulated_elapsed.num_milliseconds(),
|
|
"Mock time should advance at the same rate as real time"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_availability_with_specific_time() {
|
|
// Test that availability windows work correctly with a specific time
|
|
// This validates that the mock time would affect availability checks
|
|
|
|
let window = TimeWindow::new(
|
|
DaysOfWeek::ALL_DAYS,
|
|
WallClock::new(14, 0).unwrap(), // 2 PM
|
|
WallClock::new(18, 0).unwrap(), // 6 PM
|
|
);
|
|
|
|
// Time within window
|
|
let in_window = Local.with_ymd_and_hms(2025, 12, 25, 15, 0, 0).unwrap();
|
|
assert!(
|
|
window.contains(&in_window),
|
|
"15:00 should be within 14:00-18:00 window"
|
|
);
|
|
|
|
// Time before window
|
|
let before_window = Local.with_ymd_and_hms(2025, 12, 25, 10, 0, 0).unwrap();
|
|
assert!(
|
|
!window.contains(&before_window),
|
|
"10:00 should be before 14:00-18:00 window"
|
|
);
|
|
|
|
// Time after window
|
|
let after_window = Local.with_ymd_and_hms(2025, 12, 25, 20, 0, 0).unwrap();
|
|
assert!(
|
|
!window.contains(&after_window),
|
|
"20:00 should be after 14:00-18:00 window"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_availability_with_day_restriction() {
|
|
// Test that day-of-week restrictions work correctly
|
|
let window = TimeWindow::new(
|
|
DaysOfWeek::WEEKDAYS,
|
|
WallClock::new(14, 0).unwrap(),
|
|
WallClock::new(18, 0).unwrap(),
|
|
);
|
|
|
|
// Thursday at 3 PM - should be available (weekday, in time window)
|
|
let thursday = Local.with_ymd_and_hms(2025, 12, 25, 15, 0, 0).unwrap(); // Christmas 2025 is Thursday
|
|
assert!(
|
|
window.contains(&thursday),
|
|
"Thursday 15:00 should be in weekday afternoon window"
|
|
);
|
|
|
|
// Saturday at 3 PM - should NOT be available (weekend)
|
|
let saturday = Local.with_ymd_and_hms(2025, 12, 27, 15, 0, 0).unwrap();
|
|
assert!(
|
|
!window.contains(&saturday),
|
|
"Saturday should not be in weekday window"
|
|
);
|
|
|
|
// Sunday at 3 PM - should NOT be available (weekend)
|
|
let sunday = Local.with_ymd_and_hms(2025, 12, 28, 15, 0, 0).unwrap();
|
|
assert!(
|
|
!window.contains(&sunday),
|
|
"Sunday should not be in weekday window"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Tests that require running in a separate process to test environment variable handling.
|
|
/// These are integration-style tests for the mock time feature.
|
|
#[cfg(test)]
|
|
mod mock_time_integration_tests {
|
|
use super::*;
|
|
|
|
/// This test documents the expected behavior of the mock time feature.
|
|
/// Due to the static OnceLock, actual integration testing requires
|
|
/// running with the environment variable set externally.
|
|
///
|
|
/// To manually test:
|
|
/// ```bash
|
|
/// SHEPHERD_MOCK_TIME="2025-12-25 14:30:00" cargo test
|
|
/// ```
|
|
#[test]
|
|
fn test_mock_time_documentation() {
|
|
// This test verifies the mock time constants and expected behavior
|
|
assert_eq!(MOCK_TIME_ENV_VAR, "SHEPHERD_MOCK_TIME");
|
|
|
|
// The expected format is documented
|
|
let expected_format = "%Y-%m-%d %H:%M:%S";
|
|
let example = "2025-12-25 14:30:00";
|
|
assert!(NaiveDateTime::parse_from_str(example, expected_format).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(debug_assertions)]
|
|
fn test_is_mock_time_active_in_debug() {
|
|
// In debug mode, is_mock_time_active() should return based on env var
|
|
// Since we can't control the env var within a single test run due to OnceLock,
|
|
// we just verify the function doesn't panic
|
|
let _ = is_mock_time_active();
|
|
}
|
|
|
|
#[test]
|
|
fn test_now_consistency() {
|
|
// now() should return consistent, advancing times
|
|
let t1 = now();
|
|
std::thread::sleep(Duration::from_millis(50));
|
|
let t2 = now();
|
|
|
|
// t2 should be after t1
|
|
assert!(t2 > t1, "Time should advance forward");
|
|
|
|
// The difference should be approximately 50ms (with some tolerance)
|
|
let diff = t2.signed_duration_since(t1);
|
|
assert!(
|
|
diff.num_milliseconds() >= 40 && diff.num_milliseconds() <= 200,
|
|
"Expected ~50ms difference, got {}ms",
|
|
diff.num_milliseconds()
|
|
);
|
|
}
|
|
}
|