tests: add a few unit tests

Author: d-perl

Cargo.lock

@@ -9,6 +9,7 @@ elasticsearch = "9.0.0-alpha.1"
 redis = "0.32.4"
 rmp-serde = "1.3.0"
 serde = "1.0.219"
+serde_derive = "1.0.219"
 serde_json = "1.0.142"
 tokio = "1.47.0"
 toml = "0.9.5"

Cargo.toml

@@ -65,6 +65,7 @@ impl IngestorConfig {
     }
 }
 
+#[cfg(test)]
 mod tests {
     use super::*;
 
@@ -108,4 +109,58 @@ port = 9876
         assert_eq!(config.elastic.url.full_url(), "http://127.0.0.1:9876");
         assert_eq!(config.elastic.api_key, "abcdefgh==");
     }
+
+    #[test]
+    fn test_redis_defaults() {
+        let test_str = "
+[url]
+url = \"http://localhost\"
+port = 6379
+";
+        let redis: RedisConfig = toml::from_str(&test_str).unwrap();
+        assert_eq!(redis.chunk_size, 100);
+        assert_eq!(redis.blocktime_millis, 1000);
+        assert_eq!(redis.consumer_group, "log-ingestor");
+        assert_eq!(redis.consumer_id, "log-ingestor");
+    }
+
+    #[test]
+    fn test_elastic_defaults() {
+        let test_str = "
+url = { url = \"http://localhost\", port = 9200 }
+api_key = \"testkey\"
+";
+        let elastic: ElasticConfig = toml::from_str(&test_str).unwrap();
+        assert_eq!(elastic.chunk_size, 100);
+        assert_eq!(elastic.api_key, "testkey");
+        assert_eq!(elastic.url.full_url(), "http://localhost:9200");
+    }
+
+    #[test]
+    fn test_invalid_urlport_missing_field() {
+        let test_str = "
+url = \"http://localhost\"
+";
+        let result: Result<UrlPort, _> = toml::from_str(&test_str);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_invalid_toml() {
+        let test_str = "
+this is not toml
+";
+        let result: Result<RedisConfig, _> = toml::from_str(&test_str);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_from_file_error() {
+        use std::path::PathBuf;
+        let path = PathBuf::from("/nonexistent/config.toml");
+        let result = std::panic::catch_unwind(|| {
+            IngestorConfig::from_file(path);
+        });
+        assert!(result.is_err());
+    }
 }

src/config.rs

@@ -60,4 +60,96 @@ pub async fn consumer_loop(rx: &mut mpsc::UnboundedReceiver<LogRecord>, config:
     println!("Producer dropped, consumer exiting");
 }
 
-mod tests {}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+    struct DummyLog {
+        msg: String,
+        level: String,
+    }
+
+    // Implement LogRecord for test if not already present
+    impl From<DummyLog> for LogRecord {
+        fn from(d: DummyLog) -> Self {
+            // Adjust this conversion as per your actual LogRecord struct
+            LogRecord {
+                elapsed: crate::redis_logs::Elapsed {
+                    repr: "".into(),
+                    seconds: 0.0,
+                },
+                exception: None,
+                extra: {}.into(),
+                file: crate::redis_logs::File {
+                    name: "".into(),
+                    path: "".into(),
+                },
+                function: "".into(),
+                level: crate::redis_logs::LogLevel {
+                    icon: "".into(),
+                    name: d.level,
+                    no: 100,
+                },
+                line: 0,
+                message: d.msg,
+                module: "".into(),
+                name: "".into(),
+                process: crate::redis_logs::NameId {
+                    name: "".into(),
+                    id: 0,
+                },
+                thread: crate::redis_logs::NameId {
+                    name: "".into(),
+                    id: 0,
+                },
+                time: crate::redis_logs::Timestamp {
+                    repr: "".into(),
+                    timestamp: 0.0,
+                },
+            }
+        }
+    }
+
+    #[test]
+    fn test_make_docs_values_empty() {
+        let records: Vec<LogRecord> = vec![];
+        let docs = make_docs_values(&records).unwrap();
+        assert!(docs.is_empty());
+    }
+
+    #[test]
+    fn test_make_docs_values_single() {
+        let record: LogRecord = DummyLog {
+            msg: "hello".to_string(),
+            level: "info".to_string(),
+        }
+        .into();
+        let docs = make_docs_values(&vec![record.clone()]).unwrap();
+        // Each record should produce two JSON bodies (action + doc)
+        assert_eq!(docs.len(), 2);
+    }
+
+    #[test]
+    fn test_make_docs_values_multiple() {
+        let record1: LogRecord = DummyLog {
+            msg: "a".to_string(),
+            level: "info".to_string(),
+        }
+        .into();
+        let record2: LogRecord = DummyLog {
+            msg: "b".to_string(),
+            level: "warn".to_string(),
+        }
+        .into();
+        let docs = make_docs_values(&vec![record1, record2]).unwrap();
+        assert_eq!(docs.len(), 4);
+    }
+
+    #[test]
+    fn test_elastic_client_invalid_url() {
+        let result = elastic_client("not a url", "apikey");
+        assert!(result.is_err());
+    }
+}