Add session schedule struct encapsulating valid variants

Author: davidsteiner

crates/hotfix/src/config.rs

@@ -143,7 +143,7 @@ weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
         assert_eq!(config.sessions.len(), 1);
         let session = config.sessions.first().unwrap();
 
-        assert_eq!(session.schedule.is_some(), true);
+        assert!(session.schedule.is_some());
         let schedule = session.schedule.as_ref().unwrap();
 
         assert_eq!(schedule.start_time, NaiveTime::from_hms_opt(0, 0, 0));
@@ -185,7 +185,7 @@ end_day = "Friday"
         assert_eq!(config.sessions.len(), 1);
         let session = config.sessions.first().unwrap();
 
-        assert_eq!(session.schedule.is_some(), true);
+        assert!(session.schedule.is_some());
         let schedule = session.schedule.as_ref().unwrap();
 
         assert_eq!(schedule.start_time, NaiveTime::from_hms_opt(0, 0, 0));

crates/hotfix/src/error.rs

@@ -19,3 +19,9 @@ pub enum MessageVerificationError {
     #[error("incorrect comp id {0}")]
     IncorrectCompId(String),
 }
+
+#[derive(Debug, Error)]
+pub enum SessionError {
+    #[error("Schedule configuration is invalid: {0}")]
+    InvalidSchedule(String),
+}

crates/hotfix/src/lib.rs

@@ -30,6 +30,7 @@ pub mod initiator;
 pub mod message;
 mod message_utils;
 pub(crate) mod session;
+mod session_schedule;
 pub mod store;
 pub(crate) mod transport;
 

crates/hotfix/src/session_schedule.rs

@@ -0,0 +1,349 @@
+use chrono::{NaiveTime, Weekday};
+
+use crate::config::ScheduleConfig;
+use crate::error::SessionError;
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub enum SessionSchedule {
+    NonStop,
+    Daily {
+        start_time: NaiveTime,
+        end_time: NaiveTime,
+    },
+    Weekdays {
+        start_time: NaiveTime,
+        end_time: NaiveTime,
+        weekdays: Vec<Weekday>,
+    },
+    Weekly {
+        start_day: Weekday,
+        start_time: NaiveTime,
+        end_day: Weekday,
+        end_time: NaiveTime,
+    },
+}
+
+impl TryFrom<ScheduleConfig> for SessionSchedule {
+    type Error = SessionError;
+
+    fn try_from(config: ScheduleConfig) -> Result<Self, Self::Error> {
+        match config {
+            // NonStop: no configuration provided
+            ScheduleConfig {
+                start_time: None,
+                end_time: None,
+                start_day: None,
+                end_day: None,
+                weekdays,
+            } if weekdays.is_empty() => Ok(SessionSchedule::NonStop),
+
+            // Daily/Weekdays sessions
+            ScheduleConfig {
+                start_time: Some(start),
+                end_time: Some(end),
+                start_day: None,
+                end_day: None,
+                weekdays,
+            } => {
+                if weekdays.is_empty() {
+                    if start == end {
+                        Ok(SessionSchedule::NonStop)
+                    } else {
+                        Ok(SessionSchedule::Daily {
+                            start_time: start,
+                            end_time: end,
+                        })
+                    }
+                } else if start == end {
+                    Err(SessionError::InvalidSchedule(
+                        "Start and end times cannot be equal when weekdays is set".to_string(),
+                    ))
+                } else {
+                    Ok(SessionSchedule::Weekdays {
+                        start_time: start,
+                        end_time: end,
+                        weekdays,
+                    })
+                }
+            }
+
+            // Weekly sessions
+            ScheduleConfig {
+                start_time: Some(start),
+                end_time: Some(end),
+                start_day: Some(start_day),
+                end_day: Some(end_day),
+                weekdays,
+            } => {
+                // Weekdays should be empty for weekly sessions
+                if !weekdays.is_empty() {
+                    return Err(SessionError::InvalidSchedule(
+                        "Weekly sessions cannot have weekdays specified".to_string(),
+                    ));
+                }
+
+                Ok(SessionSchedule::Weekly {
+                    start_day,
+                    start_time: start,
+                    end_day,
+                    end_time: end,
+                })
+            }
+
+            // Invalid combinations
+            _ => Err(SessionError::InvalidSchedule(
+                "Invalid schedule configuration: incomplete or conflicting parameters".to_string(),
+            )),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::{NaiveTime, Weekday};
+
+    #[test]
+    fn test_non_stop_no_config() {
+        let config = ScheduleConfig {
+            start_time: None,
+            end_time: None,
+            start_day: None,
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        assert!(matches!(schedule, SessionSchedule::NonStop));
+    }
+
+    #[test]
+    fn test_non_stop_equal_times() {
+        let time = NaiveTime::from_hms_opt(9, 0, 0).unwrap();
+        let config = ScheduleConfig {
+            start_time: Some(time),
+            end_time: Some(time),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        assert!(matches!(schedule, SessionSchedule::NonStop));
+    }
+
+    #[test]
+    fn test_daily_session() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        match schedule {
+            SessionSchedule::Daily {
+                start_time,
+                end_time,
+            } => {
+                assert_eq!(start_time, NaiveTime::from_hms_opt(9, 0, 0).unwrap());
+                assert_eq!(end_time, NaiveTime::from_hms_opt(17, 0, 0).unwrap());
+            }
+            _ => panic!("Expected Daily schedule"),
+        }
+    }
+
+    #[test]
+    fn test_weekdays_session() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![
+                Weekday::Mon,
+                Weekday::Tue,
+                Weekday::Wed,
+                Weekday::Thu,
+                Weekday::Fri,
+            ],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        match schedule {
+            SessionSchedule::Weekdays {
+                start_time,
+                end_time,
+                weekdays,
+            } => {
+                assert_eq!(start_time, NaiveTime::from_hms_opt(9, 0, 0).unwrap());
+                assert_eq!(end_time, NaiveTime::from_hms_opt(17, 0, 0).unwrap());
+                assert_eq!(
+                    weekdays,
+                    vec![
+                        Weekday::Mon,
+                        Weekday::Tue,
+                        Weekday::Wed,
+                        Weekday::Thu,
+                        Weekday::Fri
+                    ]
+                );
+            }
+            _ => panic!("Expected Weekdays schedule"),
+        }
+    }
+
+    #[test]
+    fn test_weekly_session() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(18, 0, 0).unwrap()),
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: Some(Weekday::Sun),
+            end_day: Some(Weekday::Fri),
+            weekdays: vec![],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        match schedule {
+            SessionSchedule::Weekly {
+                start_day,
+                start_time,
+                end_day,
+                end_time,
+            } => {
+                assert_eq!(start_day, Weekday::Sun);
+                assert_eq!(start_time, NaiveTime::from_hms_opt(18, 0, 0).unwrap());
+                assert_eq!(end_day, Weekday::Fri);
+                assert_eq!(end_time, NaiveTime::from_hms_opt(17, 0, 0).unwrap());
+            }
+            _ => panic!("Expected Weekly schedule"),
+        }
+    }
+
+    #[test]
+    fn test_weekly_session_with_equal_times_is_still_weekly() {
+        let time = NaiveTime::from_hms_opt(12, 0, 0).unwrap();
+        let config = ScheduleConfig {
+            start_time: Some(time),
+            end_time: Some(time),
+            start_day: Some(Weekday::Mon),
+            end_day: Some(Weekday::Fri),
+            weekdays: vec![],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        assert!(matches!(schedule, SessionSchedule::Weekly { .. }));
+    }
+
+    #[test]
+    fn test_invalid_weekly_with_weekdays() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: Some(Weekday::Mon),
+            end_day: Some(Weekday::Fri),
+            weekdays: vec![Weekday::Mon], // This should cause an error
+        };
+
+        let result = SessionSchedule::try_from(config);
+        assert!(result.is_err());
+        match result.unwrap_err() {
+            SessionError::InvalidSchedule(msg) => {
+                assert!(msg.contains("Weekly sessions cannot have weekdays specified"));
+            }
+        }
+    }
+
+    #[test]
+    fn test_invalid_partial_config_start_time_only() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: None,
+            start_day: None,
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let result = SessionSchedule::try_from(config);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_invalid_partial_config_end_time_only() {
+        let config = ScheduleConfig {
+            start_time: None,
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let result = SessionSchedule::try_from(config);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_invalid_partial_config_start_day_only() {
+        let config = ScheduleConfig {
+            start_time: None,
+            end_time: None,
+            start_day: Some(Weekday::Mon),
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let result = SessionSchedule::try_from(config);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_invalid_mixed_config() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: None,
+            start_day: Some(Weekday::Mon),
+            end_day: None,
+            weekdays: vec![],
+        };
+
+        let result = SessionSchedule::try_from(config);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_weekdays_with_single_day() {
+        let config = ScheduleConfig {
+            start_time: Some(NaiveTime::from_hms_opt(9, 0, 0).unwrap()),
+            end_time: Some(NaiveTime::from_hms_opt(17, 0, 0).unwrap()),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![Weekday::Sat],
+        };
+
+        let schedule = SessionSchedule::try_from(config).unwrap();
+        match schedule {
+            SessionSchedule::Weekdays { weekdays, .. } => {
+                assert_eq!(weekdays, vec![Weekday::Sat]);
+            }
+            _ => panic!("Expected Weekdays schedule"),
+        }
+    }
+
+    #[test]
+    fn test_weekdays_with_equal_times_is_invalid() {
+        let time = NaiveTime::from_hms_opt(10, 30, 0).unwrap();
+        let config = ScheduleConfig {
+            start_time: Some(time),
+            end_time: Some(time),
+            start_day: None,
+            end_day: None,
+            weekdays: vec![Weekday::Mon, Weekday::Wed, Weekday::Fri],
+        };
+
+        let schedule = SessionSchedule::try_from(config);
+        assert!(schedule.is_err());
+    }
+}