feat(test): Add integration test and unit test scripts and test cases

- Added new test scripts to support unit testing, service testing, Rust unit testing and integration testing
- Add integration tests for MySQL, PostgreSQL, SQLite, ClickHouse, MSSQL databases
- Add unit tests for front-end service layer and tool functions
- Refactor `execute_with_retry` function to improve testability
- Update package.json version to 0.2.2 and add test related scripts

Author: codeErrorSleep

package.json

@@ -5,12 +5,17 @@
     "url": "git+https://github.com/codeErrorSleep/dbpaw.git"
   },
   "private": true,
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "scripts": {
     "dev": "vite",
     "dev:mock": "VITE_USE_MOCK=true vite",
     "build": "tsc && vite build",
+    "test:unit": "bash ./scripts/test-unit.sh",
+    "test:service": "bash ./scripts/test-service.sh",
+    "test:rust:unit": "cargo test --manifest-path src-tauri/Cargo.toml --lib",
+    "test:integration": "bash ./scripts/test-integration.sh",
+    "test:all": "bun run test:unit && bun run test:service && bun run test:rust:unit && bun run test:integration",
     "preview": "vite preview",
     "tauri": "tauri",
     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,css}\"",

scripts/test-integration.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+run_integration_test() {
+  local db_name="$1"
+  local test_name="$2"
+  local run_flag="$3"
+
+  if [[ "${run_flag}" != "1" ]]; then
+    echo "[skip] ${db_name} integration test (set ${db_name}=1 to enable)"
+    return 0
+  fi
+
+  echo "[run] ${db_name} integration test: ${test_name}"
+  cargo test \
+    --manifest-path src-tauri/Cargo.toml \
+    --test "${test_name}" \
+    -- --ignored --nocapture
+}
+
+run_integration_test "RUN_MYSQL_IT" "mysql_integration" "${RUN_MYSQL_IT:-0}"
+run_integration_test "RUN_POSTGRES_IT" "postgres_integration" "${RUN_POSTGRES_IT:-0}"
+run_integration_test "RUN_SQLITE_IT" "sqlite_integration" "${RUN_SQLITE_IT:-0}"
+run_integration_test "RUN_MSSQL_IT" "mssql_integration" "${RUN_MSSQL_IT:-0}"
+run_integration_test "RUN_CLICKHOUSE_IT" "clickhouse_integration" "${RUN_CLICKHOUSE_IT:-0}"

scripts/test-service.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+files=()
+while IFS= read -r file; do
+  files+=("$file")
+done < <(find src -type f -name "*.service.test.ts" | sort)
+
+if [[ ${#files[@]} -eq 0 ]]; then
+  echo "[skip] no service test files found (*.service.test.ts)"
+  exit 0
+fi
+
+echo "[run] service tests (${#files[@]} files)"
+bun test "${files[@]}"

scripts/test-unit.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+files=()
+while IFS= read -r file; do
+  files+=("$file")
+done < <(find src -type f -name "*.unit.test.ts" | sort)
+
+if [[ ${#files[@]} -eq 0 ]]; then
+  echo "[skip] no unit test files found (*.unit.test.ts)"
+  exit 0
+fi
+
+echo "[run] unit tests (${#files[@]} files)"
+bun test "${files[@]}"

src-tauri/src/commands/mod.rs

@@ -11,6 +11,15 @@ use crate::state::AppState;
 use std::sync::Arc;
 use tauri::State;
 
+fn connection_pool_key(id: i64, database: &Option<String>) -> String {
+    if let Some(db) = database {
+        if !db.is_empty() {
+            return format!("{}:{}", id, db);
+        }
+    }
+    id.to_string()
+}
+
 pub async fn ensure_connection(
     state: &State<'_, AppState>,
     id: i64,
@@ -23,15 +32,7 @@ pub async fn ensure_connection_with_db(
     id: i64,
     database: Option<String>,
 ) -> Result<Arc<dyn DatabaseDriver>, String> {
-    let key = if let Some(db) = &database {
-        if !db.is_empty() {
-            format!("{}:{}", id, db)
-        } else {
-            id.to_string()
-        }
-    } else {
-        id.to_string()
-    };
+    let key = connection_pool_key(id, &database);
 
     if let Some(driver) = state.pool_manager.get_connection(&key).await {
         // Harden: Check if connection still exists in LocalDb
@@ -66,35 +67,27 @@ pub async fn ensure_connection_with_db(
     state.pool_manager.connect(&key, &form).await
 }
 
-pub async fn execute_with_retry<F, Fut, T>(
-    state: &State<'_, AppState>,
-    id: i64,
-    database: Option<String>,
-    task: F,
+async fn execute_with_retry_core<T, Ensure, EnsureFut, Remove, RemoveFut, Task, TaskFut>(
+    mut ensure: Ensure,
+    mut remove: Remove,
+    task: Task,
 ) -> Result<T, String>
 where
-    F: Fn(Arc<dyn DatabaseDriver>) -> Fut,
-    Fut: std::future::Future<Output = Result<T, String>>,
+    Ensure: FnMut() -> EnsureFut,
+    EnsureFut: std::future::Future<Output = Result<Arc<dyn DatabaseDriver>, String>>,
+    Remove: FnMut() -> RemoveFut,
+    RemoveFut: std::future::Future<Output = ()>,
+    Task: Fn(Arc<dyn DatabaseDriver>) -> TaskFut,
+    TaskFut: std::future::Future<Output = Result<T, String>>,
 {
-    let driver = ensure_connection_with_db(state, id, database.clone()).await?;
+    let driver = ensure().await?;
     match task(driver.clone()).await {
         Ok(res) => Ok(res),
         Err(e) => {
             if is_connection_error(&e) {
-                // Retry once
                 println!("[Pool] Connection error detected, retrying...");
-                let key = if let Some(db) = &database {
-                    if !db.is_empty() {
-                        format!("{}:{}", id, db)
-                    } else {
-                        id.to_string()
-                    }
-                } else {
-                    id.to_string()
-                };
-
-                state.pool_manager.remove(&key).await;
-                let driver = ensure_connection_with_db(state, id, database).await?;
+                remove().await;
+                let driver = ensure().await?;
                 task(driver).await.map_err(|e| {
                     println!("[Pool] Retry failed: {}", e);
                     e
@@ -107,6 +100,25 @@ where
     }
 }
 
+pub async fn execute_with_retry<F, Fut, T>(
+    state: &State<'_, AppState>,
+    id: i64,
+    database: Option<String>,
+    task: F,
+) -> Result<T, String>
+where
+    F: Fn(Arc<dyn DatabaseDriver>) -> Fut,
+    Fut: std::future::Future<Output = Result<T, String>>,
+{
+    let key = connection_pool_key(id, &database);
+    execute_with_retry_core(
+        || ensure_connection_with_db(state, id, database.clone()),
+        || state.pool_manager.remove(&key),
+        task,
+    )
+    .await
+}
+
 fn is_connection_error(e: &str) -> bool {
     let lower = e.to_lowercase();
     lower.contains("pool closed")
@@ -117,3 +129,173 @@ fn is_connection_error(e: &str) -> bool {
         || lower.contains("closed")
         || lower.contains("eof")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::execute_with_retry_core;
+    use crate::db::drivers::DatabaseDriver;
+    use crate::models::{
+        QueryResult, SchemaOverview, TableDataResponse, TableInfo, TableMetadata, TableStructure,
+    };
+    use async_trait::async_trait;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct MockDriver;
+
+    #[async_trait]
+    impl DatabaseDriver for MockDriver {
+        async fn close(&self) {}
+        async fn test_connection(&self) -> Result<(), String> {
+            Ok(())
+        }
+        async fn list_databases(&self) -> Result<Vec<String>, String> {
+            Ok(vec![])
+        }
+        async fn list_tables(&self, _schema: Option<String>) -> Result<Vec<TableInfo>, String> {
+            Ok(vec![])
+        }
+        async fn get_table_structure(
+            &self,
+            _schema: String,
+            _table: String,
+        ) -> Result<TableStructure, String> {
+            Err("Unimplemented".into())
+        }
+        async fn get_table_metadata(
+            &self,
+            _schema: String,
+            _table: String,
+        ) -> Result<TableMetadata, String> {
+            Err("Unimplemented".into())
+        }
+        async fn get_table_ddl(&self, _schema: String, _table: String) -> Result<String, String> {
+            Err("Unimplemented".into())
+        }
+        async fn get_table_data(
+            &self,
+            _schema: String,
+            _table: String,
+            _page: i64,
+            _limit: i64,
+            _sort_column: Option<String>,
+            _sort_direction: Option<String>,
+            _filter: Option<String>,
+            _order_by: Option<String>,
+        ) -> Result<TableDataResponse, String> {
+            Err("Unimplemented".into())
+        }
+        async fn get_table_data_chunk(
+            &self,
+            _schema: String,
+            _table: String,
+            _page: i64,
+            _limit: i64,
+            _sort_column: Option<String>,
+            _sort_direction: Option<String>,
+            _filter: Option<String>,
+            _order_by: Option<String>,
+        ) -> Result<TableDataResponse, String> {
+            Err("Unimplemented".into())
+        }
+        async fn execute_query(&self, _sql: String) -> Result<QueryResult, String> {
+            Err("Unimplemented".into())
+        }
+        async fn get_schema_overview(
+            &self,
+            _schema: Option<String>,
+        ) -> Result<SchemaOverview, String> {
+            Err("Unimplemented".into())
+        }
+    }
+
+    #[tokio::test]
+    async fn execute_with_retry_retries_once_on_connection_error_and_succeeds() {
+        let ensure_calls = Arc::new(AtomicUsize::new(0));
+        let remove_calls = Arc::new(AtomicUsize::new(0));
+        let task_calls = Arc::new(AtomicUsize::new(0));
+        let driver: Arc<dyn DatabaseDriver> = Arc::new(MockDriver);
+
+        let ensure_calls_c = ensure_calls.clone();
+        let ensure_driver = driver.clone();
+        let remove_calls_c = remove_calls.clone();
+        let task_calls_c = task_calls.clone();
+
+        let result: Result<String, String> = execute_with_retry_core(
+            move || {
+                let ensure_calls_c = ensure_calls_c.clone();
+                let ensure_driver = ensure_driver.clone();
+                async move {
+                    ensure_calls_c.fetch_add(1, Ordering::SeqCst);
+                    Ok(ensure_driver)
+                }
+            },
+            move || {
+                let remove_calls_c = remove_calls_c.clone();
+                async move {
+                    remove_calls_c.fetch_add(1, Ordering::SeqCst);
+                }
+            },
+            move |_driver| {
+                let task_calls_c = task_calls_c.clone();
+                async move {
+                    let n = task_calls_c.fetch_add(1, Ordering::SeqCst);
+                    if n == 0 {
+                        Err("[QUERY_ERROR] connection reset by peer".to_string())
+                    } else {
+                        Ok("ok".to_string())
+                    }
+                }
+            },
+        )
+        .await;
+
+        assert_eq!(result.unwrap(), "ok");
+        assert_eq!(task_calls.load(Ordering::SeqCst), 2);
+        assert_eq!(ensure_calls.load(Ordering::SeqCst), 2);
+        assert_eq!(remove_calls.load(Ordering::SeqCst), 1);
+    }
+
+    #[tokio::test]
+    async fn execute_with_retry_returns_retry_error_when_second_attempt_fails() {
+        let ensure_calls = Arc::new(AtomicUsize::new(0));
+        let remove_calls = Arc::new(AtomicUsize::new(0));
+        let task_calls = Arc::new(AtomicUsize::new(0));
+        let driver: Arc<dyn DatabaseDriver> = Arc::new(MockDriver);
+
+        let ensure_calls_c = ensure_calls.clone();
+        let ensure_driver = driver.clone();
+        let remove_calls_c = remove_calls.clone();
+        let task_calls_c = task_calls.clone();
+
+        let result: Result<String, String> = execute_with_retry_core(
+            move || {
+                let ensure_calls_c = ensure_calls_c.clone();
+                let ensure_driver = ensure_driver.clone();
+                async move {
+                    ensure_calls_c.fetch_add(1, Ordering::SeqCst);
+                    Ok(ensure_driver)
+                }
+            },
+            move || {
+                let remove_calls_c = remove_calls_c.clone();
+                async move {
+                    remove_calls_c.fetch_add(1, Ordering::SeqCst);
+                }
+            },
+            move |_driver| {
+                let task_calls_c = task_calls_c.clone();
+                async move {
+                    task_calls_c.fetch_add(1, Ordering::SeqCst);
+                    Err("[QUERY_ERROR] pool closed".to_string())
+                }
+            },
+        )
+        .await;
+
+        assert_eq!(result.unwrap_err(), "[QUERY_ERROR] pool closed");
+        assert_eq!(task_calls.load(Ordering::SeqCst), 2);
+        assert_eq!(ensure_calls.load(Ordering::SeqCst), 2);
+        assert_eq!(remove_calls.load(Ordering::SeqCst), 1);
+    }
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "DbPaw",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "identifier": "com.father.dbpaw",
   "build": {
     "beforeDevCommand": "bun run dev",
@@ -51,4 +51,4 @@
       "signingIdentity": "-"
     }
   }
-}
+}