test: Add unit tests for AI, query and transfer modules

- Added unit tests for error handling and input validation for AI modules
- Added boundary value testing for SQL execution logs
- Added path validation and row data validation tests for data transfer
- Added integration tests for AI providers and SQL logs for local databases

Author: codeErrorSleep

src-tauri/src/commands/ai.rs

@@ -51,6 +51,50 @@ fn normalize_provider_form(
     Ok(())
 }
 
+fn map_provider_lookup_error(e: &str) -> String {
+    if e.contains("[GET_AI_PROVIDER_ERROR]") {
+        "Selected AI provider does not exist".to_string()
+    } else {
+        e.to_string()
+    }
+}
+
+fn map_default_provider_error(e: &str) -> String {
+    if e.contains("[NO_ENABLED_AI_PROVIDER]") {
+        "No enabled AI provider is configured. Please enable one in AI Provider settings."
+            .to_string()
+    } else {
+        e.to_string()
+    }
+}
+
+fn ensure_provider_enabled(enabled: bool) -> Result<(), String> {
+    if enabled {
+        Ok(())
+    } else {
+        Err("Selected AI provider is disabled".to_string())
+    }
+}
+
+fn validate_conversation_requirement(
+    conversation_id: Option<i64>,
+    create_if_missing: bool,
+) -> Result<(), String> {
+    if conversation_id.is_none() && !create_if_missing {
+        Err("conversationId is required".to_string())
+    } else {
+        Ok(())
+    }
+}
+
+fn map_history_load_error(conversation_id: i64, e: &str) -> String {
+    eprintln!(
+        "[AI_HISTORY_LOAD_ERROR] Failed to load messages for conversation {}: {}",
+        conversation_id, e
+    );
+    "Failed to load conversation history".to_string()
+}
+
 async fn get_db(state: &State<'_, AppState>) -> Result<Arc<crate::db::local::LocalDb>, String> {
     let local_db = {
         let lock = state.local_db.lock().await;
@@ -170,11 +214,7 @@ async fn run_chat(
         match db.get_ai_provider_by_id(provider_id).await {
             Ok(provider) => provider,
             Err(e) => {
-                let msg = if e.contains("[GET_AI_PROVIDER_ERROR]") {
-                    "Selected AI provider does not exist".to_string()
-                } else {
-                    e
-                };
+                let msg = map_provider_lookup_error(&e);
                 emit_ai_error(
                     &app,
                     request.request_id,
@@ -188,11 +228,7 @@ async fn run_chat(
         match db.get_default_ai_provider().await {
             Ok(provider) => provider,
             Err(e) => {
-                let msg = if e.contains("[NO_ENABLED_AI_PROVIDER]") {
-                    "No enabled AI provider is configured. Please enable one in AI Provider settings.".to_string()
-                } else {
-                    e
-                };
+                let msg = map_default_provider_error(&e);
                 emit_ai_error(
                     &app,
                     request.request_id,
@@ -204,8 +240,7 @@ async fn run_chat(
         }
     };
 
-    if !provider_record.enabled {
-        let msg = "Selected AI provider is disabled".to_string();
+    if let Err(msg) = ensure_provider_enabled(provider_record.enabled) {
         emit_ai_error(
             &app,
             request.request_id,
@@ -215,6 +250,8 @@ async fn run_chat(
         return Err(msg);
     }
 
+    validate_conversation_requirement(request.conversation_id, create_if_missing)?;
+
     let api_key = db
         .decrypt_ai_api_key(&provider_record.api_key)
         .map_err(|_| {
@@ -242,7 +279,7 @@ async fn run_chat(
             )
             .await?
         }
-        None => return Err("conversationId is required".to_string()),
+        None => unreachable!("conversation requirement should be validated before this branch"),
     };
 
     let user_message = db
@@ -313,11 +350,7 @@ async fn run_chat(
     let mut existing = match db.list_ai_messages(conversation.id).await {
         Ok(messages) => messages,
         Err(e) => {
-            eprintln!(
-                "[AI_HISTORY_LOAD_ERROR] Failed to load messages for conversation {}: {}",
-                conversation.id, e
-            );
-            let client_error = "Failed to load conversation history".to_string();
+            let client_error = map_history_load_error(conversation.id, &e);
             emit_ai_error(
                 &app,
                 request.request_id.clone(),
@@ -439,3 +472,83 @@ pub async fn ai_delete_conversation(
     let db = get_db(&state).await?;
     db.delete_ai_conversation(conversation_id).await
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        ensure_provider_enabled, map_default_provider_error, map_history_load_error,
+        map_provider_lookup_error, normalize_provider_type, validate_conversation_requirement,
+    };
+
+    #[test]
+    fn normalize_provider_type_rejects_empty_value() {
+        assert_eq!(
+            normalize_provider_type("   ").unwrap_err(),
+            "providerType is required"
+        );
+    }
+
+    #[test]
+    fn normalize_provider_type_maps_openai_compat_to_openai() {
+        assert_eq!(
+            normalize_provider_type("OpenAI_Compat").unwrap(),
+            "openai".to_string()
+        );
+    }
+
+    #[test]
+    fn normalize_provider_type_rejects_invalid_chars() {
+        assert_eq!(
+            normalize_provider_type("bad type!").unwrap_err(),
+            "providerType has invalid format"
+        );
+    }
+
+    #[test]
+    fn normalize_provider_type_accepts_supported_chars() {
+        assert_eq!(
+            normalize_provider_type("x.y-z_1").unwrap(),
+            "x.y-z_1".to_string()
+        );
+    }
+
+    #[test]
+    fn provider_lookup_error_maps_not_found_to_user_friendly_message() {
+        assert_eq!(
+            map_provider_lookup_error("[GET_AI_PROVIDER_ERROR] row not found"),
+            "Selected AI provider does not exist"
+        );
+    }
+
+    #[test]
+    fn default_provider_error_maps_no_enabled_provider_to_user_friendly_message() {
+        assert_eq!(
+            map_default_provider_error("[NO_ENABLED_AI_PROVIDER] nothing configured"),
+            "No enabled AI provider is configured. Please enable one in AI Provider settings."
+        );
+    }
+
+    #[test]
+    fn ensure_provider_enabled_rejects_disabled_provider() {
+        assert_eq!(
+            ensure_provider_enabled(false).unwrap_err(),
+            "Selected AI provider is disabled"
+        );
+    }
+
+    #[test]
+    fn continue_requires_conversation_id() {
+        assert_eq!(
+            validate_conversation_requirement(None, false).unwrap_err(),
+            "conversationId is required"
+        );
+    }
+
+    #[test]
+    fn history_load_error_maps_to_client_message() {
+        assert_eq!(
+            map_history_load_error(42, "[DB_ERROR] broken"),
+            "Failed to load conversation history"
+        );
+    }
+}

src-tauri/src/commands/query.rs

@@ -668,12 +668,16 @@ pub async fn execute_by_conn(
     result
 }
 
+fn clamp_sql_execution_logs_limit(limit: Option<i64>) -> i64 {
+    limit.unwrap_or(100).clamp(1, 100)
+}
+
 #[tauri::command]
 pub async fn list_sql_execution_logs(
     state: State<'_, AppState>,
     limit: Option<i64>,
 ) -> Result<Vec<SqlExecutionLog>, String> {
-    let safe_limit = limit.unwrap_or(100).clamp(1, 100);
+    let safe_limit = clamp_sql_execution_logs_limit(limit);
     let local_db = {
         let lock = state.local_db.lock().await;
         lock.clone()
@@ -688,7 +692,7 @@ pub async fn list_sql_execution_logs(
 
 #[cfg(test)]
 mod tests {
-    use super::maybe_apply_default_limit;
+    use super::{clamp_sql_execution_logs_limit, maybe_apply_default_limit};
 
     #[test]
     fn adds_limit_to_simple_select() {
@@ -817,4 +821,21 @@ mod tests {
             "SELECT TOP 20 * FROM t"
         );
     }
+
+    #[test]
+    fn sql_logs_limit_defaults_to_100() {
+        assert_eq!(clamp_sql_execution_logs_limit(None), 100);
+    }
+
+    #[test]
+    fn sql_logs_limit_clamps_lower_bound() {
+        assert_eq!(clamp_sql_execution_logs_limit(Some(0)), 1);
+        assert_eq!(clamp_sql_execution_logs_limit(Some(-5)), 1);
+    }
+
+    #[test]
+    fn sql_logs_limit_clamps_upper_bound() {
+        assert_eq!(clamp_sql_execution_logs_limit(Some(101)), 100);
+        assert_eq!(clamp_sql_execution_logs_limit(Some(9999)), 100);
+    }
 }

src-tauri/src/commands/transfer.rs

@@ -470,6 +470,9 @@ fn quote_target(schema: Option<&str>, table: &str, driver: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::fs;
+    use std::path::PathBuf;
+    use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
     fn csv_escape_works() {
@@ -513,4 +516,53 @@ mod tests {
         assert_eq!(quote_target(Some("  "), "users", "postgres"), "\"users\"");
         assert_eq!(quote_target(None, "users", "mysql"), "`users`");
     }
+
+    #[test]
+    fn validate_output_path_rejects_empty_path() {
+        assert_eq!(
+            validate_output_path(&PathBuf::new()).unwrap_err(),
+            "[EXPORT_ERROR] Invalid output path"
+        );
+    }
+
+    #[test]
+    fn validate_output_path_rejects_directory_path() {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!("dbpaw-transfer-test-dir-{unique}"));
+        fs::create_dir_all(&dir).unwrap();
+        let err = validate_output_path(&dir).unwrap_err();
+        assert_eq!(err, "[EXPORT_ERROR] Output path points to a directory");
+        let _ = fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn validate_output_path_rejects_path_without_filename() {
+        let err = validate_output_path(&PathBuf::from("/")).unwrap_err();
+        assert_eq!(err, "[EXPORT_ERROR] Output path must include a file name");
+    }
+
+    #[test]
+    fn write_rows_rejects_non_object_rows() {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!("dbpaw-transfer-test-{unique}.json"));
+        let mut writer = ExportWriter::new(path.clone(), ExportFormat::Json, vec!["a".to_string()])
+            .unwrap();
+        let err = writer
+            .write_rows(
+                &[Value::String("not-object".to_string())],
+                &["a".to_string()],
+                None,
+                "t",
+                "postgres",
+            )
+            .unwrap_err();
+        assert_eq!(err, "[EXPORT_ERROR] row is not a JSON object");
+        let _ = fs::remove_file(path);
+    }
 }