test: add unit tests for cli and table modules

Author: esadek

src/cli.rs

@@ -119,4 +119,39 @@ mod tests {
         assert!(result.is_err());
         assert!(result.unwrap_err().contains("key cannot be empty"));
     }
+
+    #[test]
+    fn test_database_config_creation() {
+        let config = DatabaseConfig {
+            driver_name: "test_driver".to_string(),
+            uri: Some("test_uri".to_string()),
+            username: Some("test_user".to_string()),
+            password: Some("test_pass".to_string()),
+            options: vec![("key1".to_string(), "val1".to_string())],
+        };
+
+        assert_eq!(config.driver_name, "test_driver");
+        assert_eq!(config.uri, Some("test_uri".to_string()));
+        assert_eq!(config.username, Some("test_user".to_string()));
+        assert_eq!(config.password, Some("test_pass".to_string()));
+        assert_eq!(config.options.len(), 1);
+        assert_eq!(config.options[0], ("key1".to_string(), "val1".to_string()));
+    }
+
+    #[test]
+    fn test_database_config_with_none_fields() {
+        let config = DatabaseConfig {
+            driver_name: "test_driver".to_string(),
+            uri: None,
+            username: None,
+            password: None,
+            options: vec![],
+        };
+
+        assert_eq!(config.driver_name, "test_driver");
+        assert_eq!(config.uri, None);
+        assert_eq!(config.username, None);
+        assert_eq!(config.password, None);
+        assert!(config.options.is_empty());
+    }
 }

src/table.rs

@@ -46,3 +46,134 @@ fn create_table(results: &[RecordBatch]) -> Result<Table, ArrowError> {
 
     Ok(table)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::{ArrayRef, Int32Array, StringArray};
+    use arrow_schema::{DataType, Field, Schema};
+    use std::sync::Arc;
+
+    fn create_test_schema() -> Schema {
+        Schema::new(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new("name", DataType::Utf8, false),
+        ])
+    }
+
+    fn create_test_batch() -> RecordBatch {
+        let schema = Arc::new(create_test_schema());
+        let id_array: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3]));
+        let name_array: ArrayRef = Arc::new(StringArray::from(vec!["Alice", "Bob", "Charlie"]));
+
+        RecordBatch::try_new(schema, vec![id_array, name_array]).unwrap()
+    }
+
+    #[test]
+    fn test_create_table_empty() {
+        let results: Vec<RecordBatch> = vec![];
+        let table = create_table(&results).unwrap();
+        // Empty table should be created successfully with no panic
+        let _table_str = table.to_string();
+    }
+
+    #[test]
+    fn test_create_table_single_batch() {
+        let batch = create_test_batch();
+        let results = vec![batch];
+        let table = create_table(&results).unwrap();
+        let table_str = table.to_string();
+
+        // Should contain headers
+        assert!(table_str.contains("id"));
+        assert!(table_str.contains("name"));
+
+        // Should contain data
+        assert!(table_str.contains("1"));
+        assert!(table_str.contains("Alice"));
+        assert!(table_str.contains("2"));
+        assert!(table_str.contains("Bob"));
+        assert!(table_str.contains("3"));
+        assert!(table_str.contains("Charlie"));
+    }
+
+    #[test]
+    fn test_create_table_multiple_batches() {
+        let batch1 = create_test_batch();
+        let batch2 = create_test_batch();
+        let results = vec![batch1, batch2];
+        let table = create_table(&results).unwrap();
+        let table_str = table.to_string();
+
+        // Should have data from both batches (6 rows total)
+        assert!(table_str.contains("Alice"));
+        assert!(table_str.contains("Bob"));
+        assert!(table_str.contains("Charlie"));
+    }
+
+    #[test]
+    fn test_create_table_mismatched_columns() {
+        let schema1 = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new("name", DataType::Utf8, false),
+        ]));
+
+        let schema2 = Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)]));
+
+        let batch1 = RecordBatch::try_new(
+            schema1,
+            vec![
+                Arc::new(Int32Array::from(vec![1])),
+                Arc::new(StringArray::from(vec!["Alice"])),
+            ],
+        )
+        .unwrap();
+
+        let batch2 =
+            RecordBatch::try_new(schema2, vec![Arc::new(Int32Array::from(vec![2]))]).unwrap();
+
+        let results = vec![batch1, batch2];
+        let result = create_table(&results);
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("Expected the same number of columns")
+        );
+    }
+
+    #[test]
+    fn test_print_batches_empty() {
+        let results: Vec<RecordBatch> = vec![];
+        // Should not panic on empty results
+        let result = print_batches(&results);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_create_table_with_nulls() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int32, true),
+            Field::new("name", DataType::Utf8, true),
+        ]));
+
+        let id_array: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), None, Some(3)]));
+        let name_array: ArrayRef =
+            Arc::new(StringArray::from(vec![Some("Alice"), Some("Bob"), None]));
+
+        let batch = RecordBatch::try_new(schema, vec![id_array, name_array]).unwrap();
+        let results = vec![batch];
+        let table = create_table(&results).unwrap();
+        let table_str = table.to_string();
+
+        // Should contain headers
+        assert!(table_str.contains("id"));
+        assert!(table_str.contains("name"));
+
+        // Should contain data
+        assert!(table_str.contains("1"));
+        assert!(table_str.contains("Alice"));
+        assert!(table_str.contains("Bob"));
+    }
+}