Some config tests

1 files changed, 147 insertions, 0 deletions

diff --git a/src/config.rs b/src/config.rs
index c6306bc..07be6db 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -214,3 +214,150 @@ pub fn load<P: AsRef<Path>>(path: P) -> anyhow::Result<Config> {
     }
     Ok(config)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rumqttc::QoS;
+    use std::time::Duration;
+
+    #[test]
+    fn load_full_config() {
+        let toml_str = r#"
+            host = "foo.bar.baz"
+            port = 1234
+            qos = "at-most-once"
+            id = "custom-id"
+            timeout = 15.5
+
+            [credentials]
+            username = "testuser"
+            password = "testpassword"
+
+            [routes]
+            "topic/map" = { programs = [["/bin/program1"], ["/bin/program2", "arg"]], qos = "exactly-once" }
+            "topic/seq" = [["/bin/program3", "arg"]]
+        "#;
+
+        let config: Config = toml::from_str(toml_str).expect("Failed to parse full config");
+
+        assert_eq!(config.host, "foo.bar.baz");
+        assert_eq!(config.port, 1234);
+        assert_eq!(config.qos, QoS::AtMostOnce);
+        assert_eq!(config.id, "custom-id");
+        assert_eq!(config.timeout, Duration::from_secs_f64(15.5));
+
+        let creds = config.credentials.expect("Credentials should be present");
+        assert_eq!(creds.username, "testuser");
+        assert_eq!(creds.password, "testpassword");
+
+        assert_eq!(config.routes.len(), 2);
+
+        let route_map = config.routes.get("topic/map").unwrap();
+        assert_eq!(
+            route_map.programs,
+            vec![vec!["/bin/program1"], vec!["/bin/program2", "arg"]]
+        );
+        assert_eq!(route_map.qos, Some(QoS::ExactlyOnce));
+
+        let route_seq = config.routes.get("topic/seq").unwrap();
+        assert_eq!(route_seq.programs, vec![vec!["/bin/program3", "arg"]]);
+        assert_eq!(route_seq.qos, None);
+    }
+
+    #[test]
+    fn load_minimal_config() {
+        let config: Config = toml::from_str("[routes]").expect("Failed to parse minimal config");
+
+        assert_eq!(config.host, default_host());
+        assert_eq!(config.port, default_port());
+        assert_eq!(config.qos, default_qos());
+        assert_eq!(config.id, default_id());
+        assert_eq!(config.timeout, default_timeout());
+        assert!(config.credentials.is_none());
+        assert!(config.routes.is_empty());
+    }
+
+    #[test]
+    fn load_route_seq() {
+        let toml_str = r#"
+            [routes]
+            "some/topic" = [["/foo/bar"], ["/baz/qux", "arg"]]
+        "#;
+
+        let config: Config = toml::from_str(toml_str).unwrap();
+        let route = config.routes.get("some/topic").unwrap();
+
+        assert_eq!(
+            route.programs,
+            vec![vec!["/foo/bar"], vec!["/baz/qux", "arg"]]
+        );
+        assert_eq!(route.qos, None);
+    }
+
+    #[test]
+    fn load_route_map() {
+        let toml_str = r#"
+            [routes]
+            "topic/with_qos" = { programs = [["/foo/bar", "arg"]], qos = "at-least-once" }
+            "topic/without_qos" = { programs = [["/baz/qux"]] }
+        "#;
+
+        let config: Config = toml::from_str(toml_str).unwrap();
+
+        let route_with_qos = config.routes.get("topic/with_qos").unwrap();
+        assert_eq!(route_with_qos.programs, vec![vec!["/foo/bar", "arg"]]);
+        assert_eq!(route_with_qos.qos, Some(QoS::AtLeastOnce));
+
+        let route_without_qos = config.routes.get("topic/without_qos").unwrap();
+        assert_eq!(route_without_qos.programs, vec![vec!["/baz/qux"]]);
+        assert_eq!(route_without_qos.qos, None);
+    }
+
+    #[test]
+    fn load_timeout() {
+        let config_int: Config = toml::from_str("timeout = 10\n[routes]").unwrap();
+        assert_eq!(config_int.timeout, Duration::from_secs(10));
+
+        let config_float: Config = toml::from_str("timeout = 2.5\n[routes]").unwrap();
+        assert_eq!(config_float.timeout, Duration::from_secs_f64(2.5));
+
+        let config_zero: Config = toml::from_str("timeout = 0\n[routes]").unwrap();
+        assert_eq!(config_zero.timeout, Duration::MAX);
+
+        let config_zero: Config = toml::from_str("timeout = 0.0\n[routes]").unwrap();
+        assert_eq!(config_zero.timeout, Duration::MAX);
+    }
+
+    #[test]
+    fn load_timeout_negative() {
+        let result = toml::from_str::<Config>("timeout = -10\n[routes]");
+        assert!(result.is_err());
+
+        let result = toml::from_str::<Config>("timeout = -1.0\n[routes]");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn load_qos() {
+        let toml_str = r#"
+            [routes]
+            "at-most-once" = { programs = [], qos = "at-most-once" }
+            "at-least-once" = { programs = [], qos = "at-least-once" }
+            "exactly-once" = { programs = [], qos = "exactly-once" }
+        "#;
+        let config: Config = toml::from_str(toml_str).unwrap();
+        assert_eq!(
+            config.routes.get("at-most-once").unwrap().qos.unwrap(),
+            QoS::AtMostOnce
+        );
+        assert_eq!(
+            config.routes.get("at-least-once").unwrap().qos.unwrap(),
+            QoS::AtLeastOnce
+        );
+        assert_eq!(
+            config.routes.get("exactly-once").unwrap().qos.unwrap(),
+            QoS::ExactlyOnce
+        );
+    }
+}