feat(tests): wrap the tests so that even if they fail, they still close their db connections

Cargo.toml

@@ -84,6 +84,6 @@ debug = false
 
 # Test configuration to prevent resource contention
 [[test]]
-name = "integration"
+name = "integration_smart_sync_deep_scan"
 path = "tests/integration_smart_sync_deep_scan.rs"
 harness = true

src/db/mod.rs

@@ -57,6 +57,11 @@ impl Database {
         &self.pool
     }
 
+    /// Close the database connection pool
+    pub async fn close(&self) {
+        self.pool.close().await;
+    }
+
     /// Get database connection pool health information
     pub fn get_pool_health(&self) -> DatabasePoolHealth {
         DatabasePoolHealth {

src/scheduling/source_scheduler.rs

@@ -327,98 +327,131 @@ impl SourceScheduler {
             }
         }
         
-        // Atomically start the sync - this prevents race conditions
-        if !self.state.db.start_sync_atomic(source_id).await? {
-            return Err("Could not start sync - source is already syncing or does not exist".into());
+        // First check if the source exists
+        let source = match self.state.db.get_source_by_id(source_id).await? {
+            Some(s) => s,
+            None => return Err("Source not found".into()),
+        };
+        
+        // Validate source configuration before attempting sync
+        if let Err(e) = self.validate_source_config(&source) {
+            return Err(format!("Configuration error: {}", e).into());
         }
         
-        if let Some(source) = self.state.db.get_source_by_id(source_id).await? {
-            let sync_service = self.sync_service.clone();
-            let state_clone = self.state.clone();
-            let running_syncs_clone = self.running_syncs.clone();
+        // Atomically start the sync - this prevents race conditions
+        if !self.state.db.start_sync_atomic(source_id).await? {
+            return Err("Could not start sync - source is already syncing".into());
+        }
+        
+        let sync_service = self.sync_service.clone();
+        let state_clone = self.state.clone();
+        let running_syncs_clone = self.running_syncs.clone();
+        
+        // Create cancellation token for this sync
+        let cancellation_token = CancellationToken::new();
+        
+        // Register the sync task
+        {
+            let mut running_syncs = running_syncs_clone.write().await;
+            running_syncs.insert(source_id, cancellation_token.clone());
+        }
+        
+        tokio::spawn(async move {
+            let enable_background_ocr = true; // Could be made configurable
             
-            // Create cancellation token for this sync
-            let cancellation_token = CancellationToken::new();
+            // Create progress tracker for this sync and register it
+            let progress = Arc::new(crate::services::webdav::SyncProgress::new());
+            progress.set_phase(crate::services::webdav::SyncPhase::Initializing);
+            state_clone.sync_progress_tracker.register_sync(source_id, progress.clone());
             
-            // Register the sync task
-            {
-                let mut running_syncs = running_syncs_clone.write().await;
-                running_syncs.insert(source_id, cancellation_token.clone());
-            }
-            
-            tokio::spawn(async move {
-                let enable_background_ocr = true; // Could be made configurable
-                
-                // Create progress tracker for this sync and register it
-                let progress = Arc::new(crate::services::webdav::SyncProgress::new());
-                progress.set_phase(crate::services::webdav::SyncPhase::Initializing);
-                state_clone.sync_progress_tracker.register_sync(source_id, progress.clone());
-                
-                let sync_result = sync_service.sync_source_with_cancellation(&source, enable_background_ocr, cancellation_token).await;
-                
-                match sync_result {
-                    Ok(files_processed) => {
-                        info!("Manual sync completed for source {}: {} files processed", 
-                              source.name, files_processed);
-                        
-                        // Atomically complete the sync
-                        if let Err(e) = state_clone.db.complete_sync_atomic(
-                            source_id, 
-                            true, 
-                            Some(files_processed as i64), 
-                            None
-                        ).await {
-                            error!("Failed to atomically complete sync: {}", e);
-                            // Fallback to manual status update
-                            let _ = state_clone.db.update_source_status_atomic(
-                                source_id, 
-                                Some(crate::models::SourceStatus::Syncing), 
-                                crate::models::SourceStatus::Idle, 
-                                None
-                            ).await;
-                        }
-                    }
-                    Err(e) => {
-                        error!("Manual sync failed for source {}: {}", source.name, e);
-                        
-                        // Atomically mark sync as failed
-                        if let Err(complete_err) = state_clone.db.complete_sync_atomic(
-                            source_id, 
-                            false, 
-                            None, 
-                            Some(&format!("Sync failed: {}", e))
-                        ).await {
-                            error!("Failed to atomically mark sync as failed: {}", complete_err);
-                            // Fallback to manual status update
-                            let _ = state_clone.db.update_source_status_atomic(
-                                source_id, 
-                                Some(crate::models::SourceStatus::Syncing), 
-                                crate::models::SourceStatus::Error, 
-                                Some(&format!("Sync failed: {}", e))
-                            ).await;
-                        }
-                    }
-                }
-                
+            // Ensure cleanup happens regardless of what happens in the sync operation
+            let cleanup = || async {
                 // Cleanup: Remove the sync from running list and unregister progress tracker
                 {
                     let mut running_syncs = running_syncs_clone.write().await;
-                    running_syncs.remove(&source.id);
+                    running_syncs.remove(&source_id);
                 }
                 state_clone.sync_progress_tracker.unregister_sync(source_id);
-            });
+            };
             
-            Ok(())
-        } else {
-            // Source was deleted while we were starting sync, reset status
-            let _ = self.state.db.update_source_status_atomic(
-                source_id, 
-                Some(crate::models::SourceStatus::Syncing), 
-                crate::models::SourceStatus::Error, 
-                Some("Source not found")
+            // Execute the sync operation with a timeout to prevent hanging
+            let sync_result = tokio::time::timeout(
+                std::time::Duration::from_secs(300), // 5 minute timeout for sync operations
+                sync_service.sync_source_with_cancellation(&source, enable_background_ocr, cancellation_token)
             ).await;
-            Err("Source not found".into())
-        }
+            
+            match sync_result {
+                Ok(Ok(files_processed)) => {
+                    info!("Manual sync completed for source {}: {} files processed", 
+                          source.name, files_processed);
+                    
+                    // Atomically complete the sync
+                    if let Err(e) = state_clone.db.complete_sync_atomic(
+                        source_id, 
+                        true, 
+                        Some(files_processed as i64), 
+                        None
+                    ).await {
+                        error!("Failed to atomically complete sync: {}", e);
+                        // Fallback to manual status update - force to idle
+                        let _ = sqlx::query(
+                            "UPDATE sources SET status = 'idle', last_error = NULL, last_error_at = NULL, updated_at = NOW() WHERE id = $1"
+                        )
+                        .bind(source_id)
+                        .execute(state_clone.db.get_pool())
+                        .await;
+                    }
+                }
+                Ok(Err(e)) => {
+                    error!("Manual sync failed for source {}: {}", source.name, e);
+                    
+                    // Atomically mark sync as failed
+                    if let Err(complete_err) = state_clone.db.complete_sync_atomic(
+                        source_id, 
+                        false, 
+                        None, 
+                        Some(&format!("Sync failed: {}", e))
+                    ).await {
+                        error!("Failed to atomically mark sync as failed: {}", complete_err);
+                        // Fallback to manual status update - force to error state
+                        let error_msg = format!("Sync failed: {}", e);
+                        let _ = sqlx::query(
+                            "UPDATE sources SET status = 'error', last_error = $2, last_error_at = NOW(), updated_at = NOW() WHERE id = $1"
+                        )
+                        .bind(source_id)
+                        .bind(error_msg)
+                        .execute(state_clone.db.get_pool())
+                        .await;
+                    }
+                }
+                Err(_timeout) => {
+                    error!("Manual sync timed out for source {}", source.name);
+                    
+                    // Handle timeout by resetting to error state
+                    let error_msg = "Sync operation timed out";
+                    if let Err(complete_err) = state_clone.db.complete_sync_atomic(
+                        source_id, 
+                        false, 
+                        None, 
+                        Some(error_msg)
+                    ).await {
+                        error!("Failed to atomically mark sync as timed out: {}", complete_err);
+                        // Fallback to manual status update - force to error state
+                        let _ = sqlx::query(
+                            "UPDATE sources SET status = 'error', last_error = $2, last_error_at = NOW(), updated_at = NOW() WHERE id = $1"
+                        )
+                        .bind(source_id)
+                        .bind(error_msg)
+                        .execute(state_clone.db.get_pool())
+                        .await;
+                    }
+                }
+            }
+            
+            cleanup().await;
+        });
+        
+        Ok(())
     }
 
     pub async fn stop_sync(&self, source_id: Uuid) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
@@ -461,6 +494,35 @@ impl SourceScheduler {
         }
     }
 
+    /// Force reset a source that may be stuck in syncing state
+    /// This is used as a fail-safe mechanism for race conditions
+    pub async fn force_reset_source(&self, source_id: Uuid) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        info!("Force resetting potentially stuck source {}", source_id);
+        
+        // Remove from running syncs list
+        {
+            let mut running_syncs = self.running_syncs.write().await;
+            running_syncs.remove(&source_id);
+        }
+        
+        // Unregister from progress tracker
+        self.state.sync_progress_tracker.unregister_sync(source_id);
+        
+        // Force reset database status to idle
+        if let Err(e) = sqlx::query(
+            "UPDATE sources SET status = 'idle', last_error = 'Force reset due to stuck sync', last_error_at = NOW(), updated_at = NOW() WHERE id = $1 AND status = 'syncing'"
+        )
+        .bind(source_id)
+        .execute(self.state.db.get_pool())
+        .await {
+            error!("Failed to force reset source status: {}", e);
+            return Err(e.into());
+        }
+        
+        info!("Source {} force reset completed", source_id);
+        Ok(())
+    }
+
     /// Validates a source configuration and provides detailed error messages for debugging
     fn validate_source_config(&self, source: &crate::models::Source) -> Result<(), String> {
         use crate::models::{SourceType, WebDAVSourceConfig, S3SourceConfig, LocalFolderSourceConfig};

src/test_utils.rs

@@ -237,6 +237,7 @@ pub struct TestContext {
     pub container: Arc<ContainerAsync<Postgres>>,
     pub state: Arc<AppState>,
     context_id: String,
+    cleanup_called: Arc<std::sync::atomic::AtomicBool>,
 }
 
 #[cfg(any(test, feature = "test-utils"))]
@@ -247,6 +248,7 @@ impl Clone for TestContext {
             container: Arc::clone(&self.container),
             state: Arc::clone(&self.state),
             context_id: self.context_id.clone(),
+            cleanup_called: Arc::clone(&self.cleanup_called),
         }
     }
 }
@@ -254,6 +256,27 @@ impl Clone for TestContext {
 #[cfg(any(test, feature = "test-utils"))]
 impl Drop for TestContext {
     fn drop(&mut self) {
+        // If cleanup wasn't already called, try to perform automatic cleanup
+        if !self.cleanup_called.load(std::sync::atomic::Ordering::Acquire) {
+            // Mark cleanup as called to prevent recursive calls
+            self.cleanup_called.store(true, std::sync::atomic::Ordering::Release);
+            
+            // Spawn a blocking task to perform async cleanup
+            // Note: This is a best-effort cleanup for forgotten manual cleanup calls
+            let state = Arc::clone(&self.state);
+            std::thread::spawn(move || {
+                // Create a new runtime for cleanup if we're not in an async context
+                if let Ok(rt) = tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build() {
+                    let _ = rt.block_on(async {
+                        // Try database cleanup first
+                        state.db.close().await;
+                    });
+                }
+            });
+        }
+        
         // Decrease reference count when context is dropped
         let mut manager_guard = SHARED_DB_MANAGER.lock().unwrap();
         if let Some(ref mut manager) = manager_guard.as_mut() {
@@ -349,6 +372,7 @@ impl TestContext {
             container, 
             state,
             context_id,
+            cleanup_called: Arc::new(std::sync::atomic::AtomicBool::new(false)),
         }
     }
     
@@ -421,6 +445,25 @@ impl TestContext {
         
         Ok(())
     }
+
+    /// Close the database connection pool for this test context
+    pub async fn close_connections(&self) {
+        self.state.db.close().await;
+    }
+
+    /// Complete cleanup: database cleanup + close connections
+    pub async fn cleanup_and_close(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        // Mark cleanup as called to prevent automatic cleanup in Drop
+        self.cleanup_called.store(true, std::sync::atomic::Ordering::Release);
+        
+        // First clean up test data
+        self.cleanup_database().await?;
+        
+        // Then close the connection pool
+        self.close_connections().await;
+        
+        Ok(())
+    }
 }
 
 /// Builder pattern for test configuration to eliminate config duplication
@@ -1356,9 +1399,9 @@ impl ConcurrentTestManager {
             eprintln!("Warning: {}", e);
         }
         
-        // Clean up database
-        if let Err(e) = self.context.cleanup_database().await {
-            eprintln!("Warning: Failed to cleanup database: {}", e);
+        // Clean up database and close connections
+        if let Err(e) = self.context.cleanup_and_close().await {
+            eprintln!("Warning: Failed to cleanup database and close connections: {}", e);
         }
         
         // Wait for pool to stabilize
@@ -1368,4 +1411,73 @@ impl ConcurrentTestManager {
         
         Ok(())
     }
+}
+
+/// Macro for running integration tests with automatic database cleanup
+/// 
+/// Usage:
+/// ```rust
+/// use readur::integration_test_with_cleanup;
+/// 
+/// integration_test_with_cleanup!(test_my_function, {
+///     let user_id = create_test_user(&ctx.state.db, "testuser").await?;
+///     // Your test logic here
+///     assert_eq!(something, expected);
+///     Ok(())
+/// });
+/// ```
+#[cfg(any(test, feature = "test-utils"))]
+#[macro_export]
+macro_rules! integration_test_with_cleanup {
+    ($test_name:ident, $test_body:block) => {
+        #[tokio::test]
+        async fn $test_name() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            let ctx = $crate::test_utils::TestContext::new().await;
+            
+            // Run test logic with proper error handling
+            let result: Result<(), Box<dyn std::error::Error + Send + Sync>> = async move $test_body.await;
+            
+            // Always cleanup database connections and test data, regardless of test result
+            if let Err(e) = ctx.cleanup_and_close().await {
+                eprintln!("Warning: Test cleanup failed: {}", e);
+            }
+            
+            result
+        }
+    };
+}
+
+/// Macro for running integration tests with custom TestContext configuration and automatic cleanup
+/// 
+/// Usage:
+/// ```rust
+/// use readur::integration_test_with_config_and_cleanup;
+/// 
+/// integration_test_with_config_and_cleanup!(test_with_custom_config, 
+///     TestConfigBuilder::default().with_concurrent_ocr_jobs(1),
+///     {
+///         // Your test logic here
+///         Ok(())
+///     }
+/// );
+/// ```
+#[cfg(any(test, feature = "test-utils"))]
+#[macro_export]
+macro_rules! integration_test_with_config_and_cleanup {
+    ($test_name:ident, $config:expr, $test_body:block) => {
+        #[tokio::test]
+        async fn $test_name() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+            let ctx = $crate::test_utils::TestContext::with_config($config).await;
+            
+            // Run test logic with proper error handling
+            let result: Result<(), Box<dyn std::error::Error + Send + Sync>> = async move $test_body.await;
+            
+            // Always cleanup database connections and test data, regardless of test result
+            if let Err(e) = ctx.cleanup_and_close().await {
+                eprintln!("Warning: Test cleanup failed: {}", e);
+            }
+            
+            result
+        }
+    };
 }

tests/integration_db_tests.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod tests {
+    use anyhow::Result;
     use readur::test_utils::TestContext;
     use readur::models::{CreateUser, Document, SearchRequest};
     use chrono::Utc;
@@ -59,135 +60,226 @@ mod tests {
     #[tokio::test]
     async fn test_create_user() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
         
-        let result = db.create_user(user_data).await;
-        assert!(result.is_ok());
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+
+            let result = db.create_user(user_data).await;
+            assert!(result.is_ok());
+
+            let user = result.unwrap();
+            assert!(user.username.starts_with("testuser_"));
+            assert!(user.email.starts_with("test_") && user.email.ends_with("@example.com"));
+            assert!(user.password_hash.is_some());
+            assert_ne!(user.password_hash.as_ref().unwrap(), "password123"); // Should be hashed
+            
+            Ok(())
+        }.await;
         
-        let user = result.unwrap();
-        assert!(user.username.starts_with("testuser_"));
-        assert!(user.email.starts_with("test_") && user.email.ends_with("@example.com"));
-        assert!(user.password_hash.is_some());
-        assert_ne!(user.password_hash.as_ref().unwrap(), "password123"); // Should be hashed
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_get_user_by_username() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
         
-        let created_user = db.create_user(user_data).await.unwrap();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+
+            let created_user = db.create_user(user_data).await.unwrap();
+
+            let result = db.get_user_by_username(&created_user.username).await;
+            assert!(result.is_ok());
+
+            let found_user = result.unwrap();
+            assert!(found_user.is_some());
+
+            let user = found_user.unwrap();
+            assert_eq!(user.id, created_user.id);
+            assert_eq!(user.username, created_user.username);
+            
+            Ok(())
+        }.await;
         
-        let result = db.get_user_by_username(&created_user.username).await;
-        assert!(result.is_ok());
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        let found_user = result.unwrap();
-        assert!(found_user.is_some());
-        
-        let user = found_user.unwrap();
-        assert_eq!(user.id, created_user.id);
-        assert_eq!(user.username, created_user.username);
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_get_user_by_username_not_found() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
         
-        let result = db.get_user_by_username("nonexistent").await;
-        assert!(result.is_ok());
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+
+            let result = db.get_user_by_username("nonexistent").await;
+            assert!(result.is_ok());
+
+            let found_user = result.unwrap();
+            assert!(found_user.is_none());
+            
+            Ok(())
+        }.await;
         
-        let found_user = result.unwrap();
-        assert!(found_user.is_none());
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_create_document() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
-        let user = db.create_user(user_data).await.unwrap();
         
-        let document = create_test_document(user.id);
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+            let user = db.create_user(user_data).await.unwrap();
+
+            let document = create_test_document(user.id);
+
+            let result = db.create_document(document.clone()).await;
+            assert!(result.is_ok());
+
+            let created_doc = result.unwrap();
+            assert_eq!(created_doc.filename, document.filename);
+            assert_eq!(created_doc.user_id, user.id);
+            
+            Ok(())
+        }.await;
         
-        let result = db.create_document(document.clone()).await;
-        assert!(result.is_ok());
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        let created_doc = result.unwrap();
-        assert_eq!(created_doc.filename, document.filename);
-        assert_eq!(created_doc.user_id, user.id);
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_get_documents_by_user() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
-        let user = db.create_user(user_data).await.unwrap();
         
-        let document1 = create_test_document(user.id);
-        let document2 = create_test_document(user.id);
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+            let user = db.create_user(user_data).await.unwrap();
+
+            let document1 = create_test_document(user.id);
+            let document2 = create_test_document(user.id);
+
+            db.create_document(document1).await.unwrap();
+            db.create_document(document2).await.unwrap();
+
+            let result = db.get_documents_by_user(user.id, 10, 0).await;
+            assert!(result.is_ok());
+
+            let documents = result.unwrap();
+            assert_eq!(documents.len(), 2);
+            
+            Ok(())
+        }.await;
         
-        db.create_document(document1).await.unwrap();
-        db.create_document(document2).await.unwrap();
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        let result = db.get_documents_by_user(user.id, 10, 0).await;
-        assert!(result.is_ok());
-        
-        let documents = result.unwrap();
-        assert_eq!(documents.len(), 2);
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_search_documents() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
-        let user = db.create_user(user_data).await.unwrap();
         
-        let mut document = create_test_document(user.id);
-        document.content = Some("This is a searchable document".to_string());
-        document.ocr_text = Some("OCR searchable text".to_string());
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+            let user = db.create_user(user_data).await.unwrap();
+
+            let mut document = create_test_document(user.id);
+            document.content = Some("This is a searchable document".to_string());
+            document.ocr_text = Some("OCR searchable text".to_string());
+
+            db.create_document(document).await.unwrap();
+
+            let search_request = SearchRequest {
+                query: "searchable".to_string(),
+                tags: None,
+                mime_types: None,
+                limit: Some(10),
+                offset: Some(0),
+                include_snippets: Some(true),
+                snippet_length: Some(200),
+                search_mode: None,
+            };
+
+            let result = db.search_documents(user.id, &search_request).await;
+            assert!(result.is_ok());
+
+            let documents = result.unwrap();
+            assert_eq!(documents.len(), 1);
+            
+            Ok(())
+        }.await;
         
-        db.create_document(document).await.unwrap();
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        let search_request = SearchRequest {
-            query: "searchable".to_string(),
-            tags: None,
-            mime_types: None,
-            limit: Some(10),
-            offset: Some(0),
-            include_snippets: Some(true),
-            snippet_length: Some(200),
-            search_mode: None,
-        };
-        
-        let result = db.search_documents(user.id, &search_request).await;
-        assert!(result.is_ok());
-        
-        let documents = result.unwrap();
-        assert_eq!(documents.len(), 1);
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_update_document_ocr() {
         let ctx = TestContext::new().await;
-        let db = &ctx.state.db;
-        let user_data = create_test_user_data();
-        let user = db.create_user(user_data).await.unwrap();
         
-        let document = create_test_document(user.id);
-        let created_doc = db.create_document(document).await.unwrap();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let db = &ctx.state.db;
+            let user_data = create_test_user_data();
+            let user = db.create_user(user_data).await.unwrap();
+
+            let document = create_test_document(user.id);
+            let created_doc = db.create_document(document).await.unwrap();
+
+            let new_ocr_text = "Updated OCR text";
+            let result = db.update_document_ocr(created_doc.id, Some(new_ocr_text.to_string()), None, None, None, None).await;
+            assert!(result.is_ok());
+
+            // Verify the update by searching
+            let documents = db.get_documents_by_user(user.id, 10, 0).await.unwrap();
+            let updated_doc = documents.iter().find(|d| d.id == created_doc.id).unwrap();
+            assert_eq!(updated_doc.ocr_text.as_ref().unwrap(), new_ocr_text);
+            
+            Ok(())
+        }.await;
         
-        let new_ocr_text = "Updated OCR text";
-        let result = db.update_document_ocr(created_doc.id, Some(new_ocr_text.to_string()), None, None, None, None).await;
-        assert!(result.is_ok());
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        // Verify the update by searching
-        let documents = db.get_documents_by_user(user.id, 10, 0).await.unwrap();
-        let updated_doc = documents.iter().find(|d| d.id == created_doc.id).unwrap();
-        assert_eq!(updated_doc.ocr_text.as_ref().unwrap(), new_ocr_text);
+        result.unwrap();
     }
 }

tests/integration_hash_duplicate_detection_tests.rs

@@ -71,122 +71,188 @@ fn create_test_document(user_id: Uuid, filename: &str, file_hash: Option<String>
 #[tokio::test]
 async fn test_get_document_by_user_and_hash_found() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user_id = create_test_user(&ctx.state.db, "testuser1").await?;
-    let file_hash = "abcd1234567890";
+    
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user_id = create_test_user(&ctx.state.db, "testuser1").await?;
+        let file_hash = "abcd1234567890";
 
-    // Create a document with the hash
-    let document = create_test_document(user_id, "test.pdf", Some(file_hash.to_string()));
-    let created_doc = ctx.state.db.create_document(document).await?;
+        // Create a document with the hash
+        let document = create_test_document(user_id, "test.pdf", Some(file_hash.to_string()));
+        let created_doc = ctx.state.db.create_document(document).await?;
 
-    // Test finding the document by hash
-    let found_doc = ctx.state.db.get_document_by_user_and_hash(user_id, file_hash).await?;
+        // Test finding the document by hash
+        let found_doc = ctx.state.db.get_document_by_user_and_hash(user_id, file_hash).await?;
 
-    assert!(found_doc.is_some());
-    let found_doc = found_doc.unwrap();
-    assert_eq!(found_doc.id, created_doc.id);
-    assert_eq!(found_doc.file_hash, Some(file_hash.to_string()));
-    assert_eq!(found_doc.user_id, user_id);
+        assert!(found_doc.is_some());
+        let found_doc = found_doc.unwrap();
+        assert_eq!(found_doc.id, created_doc.id);
+        assert_eq!(found_doc.file_hash, Some(file_hash.to_string()));
+        assert_eq!(found_doc.user_id, user_id);
 
-    Ok(())
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[tokio::test]
 async fn test_get_document_by_user_and_hash_not_found() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user_id = Uuid::new_v4();
-    let non_existent_hash = "nonexistent1234567890";
+    
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user_id = Uuid::new_v4();
+        let non_existent_hash = "nonexistent1234567890";
 
-    // Test finding a non-existent hash
-    let found_doc = ctx.state.db.get_document_by_user_and_hash(user_id, non_existent_hash).await?;
+        // Test finding a non-existent hash
+        let found_doc = ctx.state.db.get_document_by_user_and_hash(user_id, non_existent_hash).await?;
 
-    assert!(found_doc.is_none());
+        assert!(found_doc.is_none());
 
-    Ok(())
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[tokio::test]
 async fn test_get_document_by_user_and_hash_different_user() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user1_id = create_test_user(&ctx.state.db, "testuser2").await?;
-    let user2_id = create_test_user(&ctx.state.db, "testuser3").await?;
-    let file_hash = "shared_hash_1234567890";
+    
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user1_id = create_test_user(&ctx.state.db, "testuser2").await?;
+        let user2_id = create_test_user(&ctx.state.db, "testuser3").await?;
+        let file_hash = "shared_hash_1234567890";
 
-    // Create a document for user1 with the hash
-    let document = create_test_document(user1_id, "test.pdf", Some(file_hash.to_string()));
-    ctx.state.db.create_document(document).await?;
+        // Create a document for user1 with the hash
+        let document = create_test_document(user1_id, "test.pdf", Some(file_hash.to_string()));
+        ctx.state.db.create_document(document).await?;
 
-    // Test that user2 cannot find user1's document by hash
-    let found_doc = ctx.state.db.get_document_by_user_and_hash(user2_id, file_hash).await?;
+        // Test that user2 cannot find user1's document by hash
+        let found_doc = ctx.state.db.get_document_by_user_and_hash(user2_id, file_hash).await?;
 
-    assert!(found_doc.is_none(), "User should not be able to access another user's documents");
+        assert!(found_doc.is_none(), "User should not be able to access another user's documents");
 
-    Ok(())
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[tokio::test]
 async fn test_duplicate_hash_prevention_same_user() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user_id = create_test_user(&ctx.state.db, "testuser4").await?;
-    let file_hash = "duplicate_hash_1234567890";
-
-    // Create first document with the hash
-    let document1 = create_test_document(user_id, "test1.pdf", Some(file_hash.to_string()));
-    let result1 = ctx.state.db.create_document(document1).await;
-    assert!(result1.is_ok(), "First document with hash should be created successfully");
-
-    // Try to create second document with same hash for same user
-    let document2 = create_test_document(user_id, "test2.pdf", Some(file_hash.to_string()));
-    let result2 = ctx.state.db.create_document(document2).await;
     
-    // This should fail due to unique constraint
-    assert!(result2.is_err(), "Second document with same hash for same user should fail");
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user_id = create_test_user(&ctx.state.db, "testuser4").await?;
+        let file_hash = "duplicate_hash_1234567890";
 
-    Ok(())
+        // Create first document with the hash
+        let document1 = create_test_document(user_id, "test1.pdf", Some(file_hash.to_string()));
+        let result1 = ctx.state.db.create_document(document1).await;
+        assert!(result1.is_ok(), "First document with hash should be created successfully");
+
+        // Try to create second document with same hash for same user
+        let document2 = create_test_document(user_id, "test2.pdf", Some(file_hash.to_string()));
+        let result2 = ctx.state.db.create_document(document2).await;
+        
+        // This should fail due to unique constraint
+        assert!(result2.is_err(), "Second document with same hash for same user should fail");
+
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[tokio::test]
 async fn test_same_hash_different_users_allowed() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user1_id = create_test_user(&ctx.state.db, "testuser5").await?;
-    let user2_id = create_test_user(&ctx.state.db, "testuser6").await?;
-    let file_hash = "shared_content_hash_1234567890";
+    
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user1_id = create_test_user(&ctx.state.db, "testuser5").await?;
+        let user2_id = create_test_user(&ctx.state.db, "testuser6").await?;
+        let file_hash = "shared_content_hash_1234567890";
 
-    // Create document for user1 with the hash
-    let document1 = create_test_document(user1_id, "test1.pdf", Some(file_hash.to_string()));
-    let result1 = ctx.state.db.create_document(document1).await;
-    assert!(result1.is_ok(), "First user's document should be created successfully");
+        // Create document for user1 with the hash
+        let document1 = create_test_document(user1_id, "test1.pdf", Some(file_hash.to_string()));
+        let result1 = ctx.state.db.create_document(document1).await;
+        assert!(result1.is_ok(), "First user's document should be created successfully");
 
-    // Create document for user2 with same hash
-    let document2 = create_test_document(user2_id, "test2.pdf", Some(file_hash.to_string()));
-    let result2 = ctx.state.db.create_document(document2).await;
-    assert!(result2.is_ok(), "Second user's document with same hash should be allowed");
+        // Create document for user2 with same hash
+        let document2 = create_test_document(user2_id, "test2.pdf", Some(file_hash.to_string()));
+        let result2 = ctx.state.db.create_document(document2).await;
+        assert!(result2.is_ok(), "Second user's document with same hash should be allowed");
 
-    // Verify both users can find their respective documents
-    let found_doc1 = ctx.state.db.get_document_by_user_and_hash(user1_id, file_hash).await?;
-    let found_doc2 = ctx.state.db.get_document_by_user_and_hash(user2_id, file_hash).await?;
+        // Verify both users can find their respective documents
+        let found_doc1 = ctx.state.db.get_document_by_user_and_hash(user1_id, file_hash).await?;
+        let found_doc2 = ctx.state.db.get_document_by_user_and_hash(user2_id, file_hash).await?;
 
-    assert!(found_doc1.is_some());
-    assert!(found_doc2.is_some());
-    assert_ne!(found_doc1.unwrap().id, found_doc2.unwrap().id);
+        assert!(found_doc1.is_some());
+        assert!(found_doc2.is_some());
+        assert_ne!(found_doc1.unwrap().id, found_doc2.unwrap().id);
 
-    Ok(())
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[tokio::test]
 async fn test_null_hash_allowed_multiple() -> Result<()> {
     let ctx = TestContext::new().await;
-    let user_id = create_test_user(&ctx.state.db, "testuser7").await?;
+    
+    // Ensure cleanup happens even if test fails
+    let result = async {
+        let user_id = create_test_user(&ctx.state.db, "testuser7").await?;
 
-    // Create multiple documents with null hash (should be allowed)
-    let document1 = create_test_document(user_id, "test1.pdf", None);
-    let result1 = ctx.state.db.create_document(document1).await;
-    assert!(result1.is_ok(), "First document with null hash should be created");
+        // Create multiple documents with null hash (should be allowed)
+        let document1 = create_test_document(user_id, "test1.pdf", None);
+        let result1 = ctx.state.db.create_document(document1).await;
+        assert!(result1.is_ok(), "First document with null hash should be created");
 
-    let document2 = create_test_document(user_id, "test2.pdf", None);
-    let result2 = ctx.state.db.create_document(document2).await;
-    assert!(result2.is_ok(), "Second document with null hash should be created");
+        let document2 = create_test_document(user_id, "test2.pdf", None);
+        let result2 = ctx.state.db.create_document(document2).await;
+        assert!(result2.is_ok(), "Second document with null hash should be created");
 
-    Ok(())
+        Ok(())
+    }.await;
+    
+    // Always cleanup database connections and test data
+    if let Err(e) = ctx.cleanup_and_close().await {
+        eprintln!("Warning: Test cleanup failed: {}", e);
+    }
+    
+    result
 }
 
 #[test]

tests/integration_ignored_files_tests.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod tests {
+    use anyhow::Result;
     use readur::db::ignored_files::{
         create_ignored_file, list_ignored_files, get_ignored_file_by_id, delete_ignored_file,
         is_file_ignored, count_ignored_files, bulk_delete_ignored_files,
@@ -14,242 +15,320 @@ mod tests {
     #[tokio::test]
     async fn test_create_ignored_file() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
 
-        let ignored_file = CreateIgnoredFile {
-            file_hash: "abc123".to_string(),
-            filename: "test.pdf".to_string(),
-            original_filename: "original_test.pdf".to_string(),
-            file_path: "/path/to/test.pdf".to_string(),
-            file_size: 1024,
-            mime_type: "application/pdf".to_string(),
-            source_type: Some("webdav".to_string()),
-            source_path: Some("/webdav/test.pdf".to_string()),
-            source_identifier: Some("webdav-server-1".to_string()),
-            ignored_by: user.user_response.id,
-            reason: Some("deleted by user".to_string()),
-        };
+            let ignored_file = CreateIgnoredFile {
+                file_hash: "abc123".to_string(),
+                filename: "test.pdf".to_string(),
+                original_filename: "original_test.pdf".to_string(),
+                file_path: "/path/to/test.pdf".to_string(),
+                file_size: 1024,
+                mime_type: "application/pdf".to_string(),
+                source_type: Some("webdav".to_string()),
+                source_path: Some("/webdav/test.pdf".to_string()),
+                source_identifier: Some("webdav-server-1".to_string()),
+                ignored_by: user.user_response.id,
+                reason: Some("deleted by user".to_string()),
+            };
 
-        let result = create_ignored_file(&ctx.state.db.pool, ignored_file).await;
-        assert!(result.is_ok());
+            let result = create_ignored_file(&ctx.state.db.pool, ignored_file).await;
+            assert!(result.is_ok());
 
-        let created = result.unwrap();
-        assert_eq!(created.file_hash, "abc123");
-        assert_eq!(created.filename, "test.pdf");
-        assert_eq!(created.ignored_by, user.user_response.id);
-        assert_eq!(created.source_type, Some("webdav".to_string()));
+            let created = result.unwrap();
+            assert_eq!(created.file_hash, "abc123");
+            assert_eq!(created.filename, "test.pdf");
+            assert_eq!(created.ignored_by, user.user_response.id);
+            assert_eq!(created.source_type, Some("webdav".to_string()));
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_list_ignored_files() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+
+            // Create multiple ignored files
+            for i in 0..3 {
+                let ignored_file = CreateIgnoredFile {
+                    file_hash: format!("hash{}", i),
+                    filename: format!("test{}.pdf", i),
+                    original_filename: format!("original_test{}.pdf", i),
+                    file_path: format!("/path/to/test{}.pdf", i),
+                    file_size: 1024 * (i + 1) as i64,
+                    mime_type: "application/pdf".to_string(),
+                    source_type: Some("webdav".to_string()),
+                    source_path: Some(format!("/webdav/test{}.pdf", i)),
+                    source_identifier: Some("webdav-server-1".to_string()),
+                    ignored_by: user.user_response.id,
+                    reason: Some("deleted by user".to_string()),
+                };
+
+                create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
+            }
+
+            let query = IgnoredFilesQuery {
+                limit: Some(10),
+                offset: Some(0),
+                source_type: None,
+                source_identifier: None,
+                ignored_by: None,
+                filename: None,
+            };
+
+            let result = list_ignored_files(&ctx.state.db.pool, user.user_response.id, &query).await;
+            assert!(result.is_ok());
+
+            let ignored_files = result.unwrap();
+            assert_eq!(ignored_files.len(), 3);
+            assert!(ignored_files.iter().all(|f| f.ignored_by == user.user_response.id));
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_get_ignored_file_by_id() {
+        let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
 
-        // Create multiple ignored files
-        for i in 0..3 {
             let ignored_file = CreateIgnoredFile {
-                file_hash: format!("hash{}", i),
-                filename: format!("test{}.pdf", i),
-                original_filename: format!("original_test{}.pdf", i),
-                file_path: format!("/path/to/test{}.pdf", i),
-                file_size: 1024 * (i + 1) as i64,
+                file_hash: "test_hash".to_string(),
+                filename: "test.pdf".to_string(),
+                original_filename: "original_test.pdf".to_string(),
+                file_path: "/path/to/test.pdf".to_string(),
+                file_size: 1024,
                 mime_type: "application/pdf".to_string(),
                 source_type: Some("webdav".to_string()),
-                source_path: Some(format!("/webdav/test{}.pdf", i)),
+                source_path: Some("/webdav/test.pdf".to_string()),
+                source_identifier: Some("webdav-server-1".to_string()),
+                ignored_by: user.user_response.id,
+                reason: Some("deleted by user".to_string()),
+            };
+
+            let created = create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
+
+            let result = get_ignored_file_by_id(&ctx.state.db.pool, created.id, user.user_response.id).await;
+            assert!(result.is_ok());
+
+            let fetched = result.unwrap();
+            assert!(fetched.is_some());
+
+            let fetched = fetched.unwrap();
+            assert_eq!(fetched.id, created.id);
+            assert_eq!(fetched.file_hash, "test_hash");
+            assert_eq!(fetched.filename, "test.pdf");
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_delete_ignored_file() {
+        let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+
+            let ignored_file = CreateIgnoredFile {
+                file_hash: "test_hash".to_string(),
+                filename: "test.pdf".to_string(),
+                original_filename: "original_test.pdf".to_string(),
+                file_path: "/path/to/test.pdf".to_string(),
+                file_size: 1024,
+                mime_type: "application/pdf".to_string(),
+                source_type: Some("webdav".to_string()),
+                source_path: Some("/webdav/test.pdf".to_string()),
+                source_identifier: Some("webdav-server-1".to_string()),
+                ignored_by: user.user_response.id,
+                reason: Some("deleted by user".to_string()),
+            };
+
+            let created = create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
+
+            let result = delete_ignored_file(&ctx.state.db.pool, created.id, user.user_response.id).await;
+            assert!(result.is_ok());
+            assert!(result.unwrap());
+
+            // Verify it's deleted
+            let fetched = get_ignored_file_by_id(&ctx.state.db.pool, created.id, user.user_response.id).await;
+            assert!(fetched.is_ok());
+            assert!(fetched.unwrap().is_none());
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_is_file_ignored() {
+        let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+
+            let ignored_file = CreateIgnoredFile {
+                file_hash: "test_hash".to_string(),
+                filename: "test.pdf".to_string(),
+                original_filename: "original_test.pdf".to_string(),
+                file_path: "/path/to/test.pdf".to_string(),
+                file_size: 1024,
+                mime_type: "application/pdf".to_string(),
+                source_type: Some("webdav".to_string()),
+                source_path: Some("/webdav/test.pdf".to_string()),
                 source_identifier: Some("webdav-server-1".to_string()),
                 ignored_by: user.user_response.id,
                 reason: Some("deleted by user".to_string()),
             };
 
             create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
+
+            // Test with exact match
+            let result = is_file_ignored(
+                &ctx.state.db.pool,
+                "test_hash",
+                Some("webdav"),
+                Some("/webdav/test.pdf")
+            ).await;
+            assert!(result.is_ok());
+            assert!(result.unwrap());
+
+            // Test with just hash
+            let result = is_file_ignored(&ctx.state.db.pool, "test_hash", None, None).await;
+            assert!(result.is_ok());
+            assert!(result.unwrap());
+
+            // Test with non-existing hash
+            let result = is_file_ignored(&ctx.state.db.pool, "non_existing", None, None).await;
+            assert!(result.is_ok());
+            assert!(!result.unwrap());
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
-
-        let query = IgnoredFilesQuery {
-            limit: Some(10),
-            offset: Some(0),
-            source_type: None,
-            source_identifier: None,
-            ignored_by: None,
-            filename: None,
-        };
-
-        let result = list_ignored_files(&ctx.state.db.pool, user.user_response.id, &query).await;
-        assert!(result.is_ok());
-
-        let ignored_files = result.unwrap();
-        assert_eq!(ignored_files.len(), 3);
-        assert!(ignored_files.iter().all(|f| f.ignored_by == user.user_response.id));
-    }
-
-    #[tokio::test]
-    async fn test_get_ignored_file_by_id() {
-        let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-
-        let ignored_file = CreateIgnoredFile {
-            file_hash: "test_hash".to_string(),
-            filename: "test.pdf".to_string(),
-            original_filename: "original_test.pdf".to_string(),
-            file_path: "/path/to/test.pdf".to_string(),
-            file_size: 1024,
-            mime_type: "application/pdf".to_string(),
-            source_type: Some("webdav".to_string()),
-            source_path: Some("/webdav/test.pdf".to_string()),
-            source_identifier: Some("webdav-server-1".to_string()),
-            ignored_by: user.user_response.id,
-            reason: Some("deleted by user".to_string()),
-        };
-
-        let created = create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
-
-        let result = get_ignored_file_by_id(&ctx.state.db.pool, created.id, user.user_response.id).await;
-        assert!(result.is_ok());
-
-        let fetched = result.unwrap();
-        assert!(fetched.is_some());
-
-        let fetched = fetched.unwrap();
-        assert_eq!(fetched.id, created.id);
-        assert_eq!(fetched.file_hash, "test_hash");
-        assert_eq!(fetched.filename, "test.pdf");
-    }
-
-    #[tokio::test]
-    async fn test_delete_ignored_file() {
-        let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-
-        let ignored_file = CreateIgnoredFile {
-            file_hash: "test_hash".to_string(),
-            filename: "test.pdf".to_string(),
-            original_filename: "original_test.pdf".to_string(),
-            file_path: "/path/to/test.pdf".to_string(),
-            file_size: 1024,
-            mime_type: "application/pdf".to_string(),
-            source_type: Some("webdav".to_string()),
-            source_path: Some("/webdav/test.pdf".to_string()),
-            source_identifier: Some("webdav-server-1".to_string()),
-            ignored_by: user.user_response.id,
-            reason: Some("deleted by user".to_string()),
-        };
-
-        let created = create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
-
-        let result = delete_ignored_file(&ctx.state.db.pool, created.id, user.user_response.id).await;
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-
-        // Verify it's deleted
-        let fetched = get_ignored_file_by_id(&ctx.state.db.pool, created.id, user.user_response.id).await;
-        assert!(fetched.is_ok());
-        assert!(fetched.unwrap().is_none());
-    }
-
-    #[tokio::test]
-    async fn test_is_file_ignored() {
-        let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-
-        let ignored_file = CreateIgnoredFile {
-            file_hash: "test_hash".to_string(),
-            filename: "test.pdf".to_string(),
-            original_filename: "original_test.pdf".to_string(),
-            file_path: "/path/to/test.pdf".to_string(),
-            file_size: 1024,
-            mime_type: "application/pdf".to_string(),
-            source_type: Some("webdav".to_string()),
-            source_path: Some("/webdav/test.pdf".to_string()),
-            source_identifier: Some("webdav-server-1".to_string()),
-            ignored_by: user.user_response.id,
-            reason: Some("deleted by user".to_string()),
-        };
-
-        create_ignored_file(&ctx.state.db.pool, ignored_file).await.unwrap();
-
-        // Test with exact match
-        let result = is_file_ignored(
-            &ctx.state.db.pool,
-            "test_hash",
-            Some("webdav"),
-            Some("/webdav/test.pdf")
-        ).await;
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-
-        // Test with just hash
-        let result = is_file_ignored(&ctx.state.db.pool, "test_hash", None, None).await;
-        assert!(result.is_ok());
-        assert!(result.unwrap());
-
-        // Test with non-existing hash
-        let result = is_file_ignored(&ctx.state.db.pool, "non_existing", None, None).await;
-        assert!(result.is_ok());
-        assert!(!result.unwrap());
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_create_ignored_file_from_document() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-        let document = ctx.state.db.create_document(readur::models::Document {
-            id: Uuid::new_v4(),
-            filename: "test_document.pdf".to_string(),
-            original_filename: "test_document.pdf".to_string(),
-            file_path: "/uploads/test_document.pdf".to_string(),
-            file_size: 1024000,
-            mime_type: "application/pdf".to_string(),
-            content: Some("Test document content".to_string()),
-            ocr_text: Some("This is extracted OCR text from the test document.".to_string()),
-            ocr_confidence: Some(95.5),
-            ocr_word_count: Some(150),
-            ocr_processing_time_ms: Some(1200),
-            ocr_status: Some("completed".to_string()),
-            ocr_error: None,
-            ocr_completed_at: Some(Utc::now()),
-            tags: vec!["test".to_string(), "document".to_string()],
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-            user_id: user.user_response.id,
-            file_hash: Some("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef".to_string()),
-            original_created_at: None,
-            original_modified_at: None,
-            source_path: None,
-            source_type: None,
-            source_id: None,
-            file_permissions: None,
-            file_owner: None,
-            file_group: None,
-            source_metadata: None,
-            ocr_retry_count: None,
-            ocr_failure_reason: None,
-        }).await.unwrap();
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+            let document = ctx.state.db.create_document(readur::models::Document {
+                id: Uuid::new_v4(),
+                filename: "test_document.pdf".to_string(),
+                original_filename: "test_document.pdf".to_string(),
+                file_path: "/uploads/test_document.pdf".to_string(),
+                file_size: 1024000,
+                mime_type: "application/pdf".to_string(),
+                content: Some("Test document content".to_string()),
+                ocr_text: Some("This is extracted OCR text from the test document.".to_string()),
+                ocr_confidence: Some(95.5),
+                ocr_word_count: Some(150),
+                ocr_processing_time_ms: Some(1200),
+                ocr_status: Some("completed".to_string()),
+                ocr_error: None,
+                ocr_completed_at: Some(Utc::now()),
+                tags: vec!["test".to_string(), "document".to_string()],
+                created_at: Utc::now(),
+                updated_at: Utc::now(),
+                user_id: user.user_response.id,
+                file_hash: Some("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef".to_string()),
+                original_created_at: None,
+                original_modified_at: None,
+                source_path: None,
+                source_type: None,
+                source_id: None,
+                file_permissions: None,
+                file_owner: None,
+                file_group: None,
+                source_metadata: None,
+                ocr_retry_count: None,
+                ocr_failure_reason: None,
+            }).await.unwrap();
 
-        let result = create_ignored_file_from_document(
-            &ctx.state.db.pool,
-            document.id,
-            user.user_response.id,
-            Some("deleted by user".to_string()),
-            Some("webdav".to_string()),
-            Some("/webdav/test.pdf".to_string()),
-            Some("webdav-server-1".to_string()),
-        ).await;
+            let result = create_ignored_file_from_document(
+                &ctx.state.db.pool,
+                document.id,
+                user.user_response.id,
+                Some("deleted by user".to_string()),
+                Some("webdav".to_string()),
+                Some("/webdav/test.pdf".to_string()),
+                Some("webdav-server-1".to_string()),
+            ).await;
 
-        assert!(result.is_ok());
-        let ignored_file = result.unwrap();
-        assert!(ignored_file.is_some());
+            assert!(result.is_ok());
+            let ignored_file = result.unwrap();
+            assert!(ignored_file.is_some());
 
-        let ignored_file = ignored_file.unwrap();
-        assert_eq!(ignored_file.filename, document.filename);
-        assert_eq!(ignored_file.file_size, document.file_size);
-        assert_eq!(ignored_file.mime_type, document.mime_type);
-        assert_eq!(ignored_file.ignored_by, user.user_response.id);
-        assert_eq!(ignored_file.source_type, Some("webdav".to_string()));
-        assert_eq!(ignored_file.reason, Some("deleted by user".to_string()));
+            let ignored_file = ignored_file.unwrap();
+            assert_eq!(ignored_file.filename, document.filename);
+            assert_eq!(ignored_file.file_size, document.file_size);
+            assert_eq!(ignored_file.mime_type, document.mime_type);
+            assert_eq!(ignored_file.ignored_by, user.user_response.id);
+            assert_eq!(ignored_file.source_type, Some("webdav".to_string()));
+            assert_eq!(ignored_file.reason, Some("deleted by user".to_string()));
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 }

tests/integration_ocr_retry_db_tests.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod tests {
+    use anyhow::Result;
     use readur::db::ocr_retry::*;
     use readur::test_utils::{TestContext, TestAuthHelper};
     use sqlx::Row;
@@ -8,35 +9,48 @@ mod tests {
     #[tokio::test]
     async fn test_simple_retry_record() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
         
-        // Create a test document using the TestContext database
-        let doc_id = Uuid::new_v4();
-        sqlx::query("INSERT INTO documents (id, filename, original_filename, user_id, mime_type, file_size, created_at, updated_at, file_path) VALUES ($1, 'test.pdf', 'test.pdf', $2, 'application/pdf', 1024, NOW(), NOW(), '/test/test.pdf')")
-            .bind(doc_id)
-            .bind(user.user_response.id)
-            .execute(&ctx.state.db.pool)
-            .await
-            .expect("Failed to create test document");
-        
-        // Test the record_ocr_retry function
-        let retry_id = record_ocr_retry(
-            &ctx.state.db.pool,
-            doc_id,
-            user.user_response.id,
-            "manual_retry",
-            10,
-            None,
-        ).await.expect("Failed to record retry");
-        
-        // Verify the retry was recorded
-        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM ocr_retry_history WHERE id = $1")
-            .bind(retry_id)
-            .fetch_one(&ctx.state.db.pool)
-            .await
-            .expect("Failed to count retries");
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+
+            // Create a test document using the TestContext database
+            let doc_id = Uuid::new_v4();
+            sqlx::query("INSERT INTO documents (id, filename, original_filename, user_id, mime_type, file_size, created_at, updated_at, file_path) VALUES ($1, 'test.pdf', 'test.pdf', $2, 'application/pdf', 1024, NOW(), NOW(), '/test/test.pdf')")
+                .bind(doc_id)
+                .bind(user.user_response.id)
+                .execute(&ctx.state.db.pool)
+                .await
+                .expect("Failed to create test document");
+
+            // Test the record_ocr_retry function
+            let retry_id = record_ocr_retry(
+                &ctx.state.db.pool,
+                doc_id,
+                user.user_response.id,
+                "manual_retry",
+                10,
+                None,
+            ).await.expect("Failed to record retry");
+
+            // Verify the retry was recorded
+            let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM ocr_retry_history WHERE id = $1")
+                .bind(retry_id)
+                .fetch_one(&ctx.state.db.pool)
+                .await
+                .expect("Failed to count retries");
+
+            assert_eq!(count, 1);
             
-        assert_eq!(count, 1);
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 }

tests/integration_settings_tests.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod tests {
+    use anyhow::Result;
     use readur::models::UpdateSettings;
     use readur::test_utils::{TestContext, TestAuthHelper};
     use axum::http::StatusCode;
@@ -8,461 +9,539 @@ mod tests {
     #[tokio::test]
     async fn test_get_settings_default() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-        let token = auth_helper.login_user(&user.username, "password123").await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+            let token = auth_helper.login_user(&user.username, "password123").await;
 
-        let response = ctx.app.clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("GET")
-                    .uri("/api/settings")
-                    .header("Authorization", format!("Bearer {}", token))
-                    .body(axum::body::Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        // Accept either OK (200) or Internal Server Error (500) for database integration tests
-        let status = response.status();
-        assert!(status == StatusCode::OK || status == StatusCode::INTERNAL_SERVER_ERROR, 
-                "Expected OK or Internal Server Error, got: {}", status);
-
-        if status == StatusCode::OK {
-            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+            let response = ctx.app.clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("GET")
+                        .uri("/api/settings")
+                        .header("Authorization", format!("Bearer {}", token))
+                        .body(axum::body::Body::empty())
+                        .unwrap(),
+                )
                 .await
                 .unwrap();
-            let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
-            assert_eq!(settings["ocr_language"], "eng");
+
+            // Accept either OK (200) or Internal Server Error (500) for database integration tests
+            let status = response.status();
+            assert!(status == StatusCode::OK || status == StatusCode::INTERNAL_SERVER_ERROR, 
+                    "Expected OK or Internal Server Error, got: {}", status);
+
+            if status == StatusCode::OK {
+                let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                    .await
+                    .unwrap();
+                let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
+                assert_eq!(settings["ocr_language"], "eng");
+            }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_update_settings() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-        let token = auth_helper.login_user(&user.username, "password123").await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+            let token = auth_helper.login_user(&user.username, "password123").await;
 
-        let update_data = UpdateSettings {
-            ocr_language: Some("spa".to_string()),
-            preferred_languages: None,
-            primary_language: None,
-            auto_detect_language_combination: None,
-            concurrent_ocr_jobs: None,
-            ocr_timeout_seconds: None,
-            max_file_size_mb: None,
-            allowed_file_types: None,
-            auto_rotate_images: None,
-            enable_image_preprocessing: None,
-            search_results_per_page: None,
-            search_snippet_length: None,
-            fuzzy_search_threshold: None,
-            retention_days: None,
-            enable_auto_cleanup: None,
-            enable_compression: None,
-            memory_limit_mb: None,
-            cpu_priority: None,
-            enable_background_ocr: None,
-            ocr_page_segmentation_mode: None,
-            ocr_engine_mode: None,
-            ocr_min_confidence: None,
-            ocr_dpi: None,
-            ocr_enhance_contrast: None,
-            ocr_remove_noise: None,
-            ocr_detect_orientation: None,
-            ocr_whitelist_chars: None,
-            ocr_blacklist_chars: None,
-            ocr_brightness_boost: None,
-            ocr_contrast_multiplier: None,
-            ocr_noise_reduction_level: None,
-            ocr_sharpening_strength: None,
-            ocr_morphological_operations: None,
-            ocr_adaptive_threshold_window_size: None,
-            ocr_histogram_equalization: None,
-            ocr_upscale_factor: None,
-            ocr_max_image_width: None,
-            ocr_max_image_height: None,
-            save_processed_images: None,
-            ocr_quality_threshold_brightness: None,
-            ocr_quality_threshold_contrast: None,
-            ocr_quality_threshold_noise: None,
-            ocr_quality_threshold_sharpness: None,
-            ocr_skip_enhancement: None,
-            webdav_enabled: None,
-            webdav_server_url: None,
-            webdav_username: None,
-            webdav_password: None,
-            webdav_watch_folders: None,
-            webdav_file_extensions: None,
-            webdav_auto_sync: None,
-            webdav_sync_interval_minutes: None,
-        };
+            let update_data = UpdateSettings {
+                ocr_language: Some("spa".to_string()),
+                preferred_languages: None,
+                primary_language: None,
+                auto_detect_language_combination: None,
+                concurrent_ocr_jobs: None,
+                ocr_timeout_seconds: None,
+                max_file_size_mb: None,
+                allowed_file_types: None,
+                auto_rotate_images: None,
+                enable_image_preprocessing: None,
+                search_results_per_page: None,
+                search_snippet_length: None,
+                fuzzy_search_threshold: None,
+                retention_days: None,
+                enable_auto_cleanup: None,
+                enable_compression: None,
+                memory_limit_mb: None,
+                cpu_priority: None,
+                enable_background_ocr: None,
+                ocr_page_segmentation_mode: None,
+                ocr_engine_mode: None,
+                ocr_min_confidence: None,
+                ocr_dpi: None,
+                ocr_enhance_contrast: None,
+                ocr_remove_noise: None,
+                ocr_detect_orientation: None,
+                ocr_whitelist_chars: None,
+                ocr_blacklist_chars: None,
+                ocr_brightness_boost: None,
+                ocr_contrast_multiplier: None,
+                ocr_noise_reduction_level: None,
+                ocr_sharpening_strength: None,
+                ocr_morphological_operations: None,
+                ocr_adaptive_threshold_window_size: None,
+                ocr_histogram_equalization: None,
+                ocr_upscale_factor: None,
+                ocr_max_image_width: None,
+                ocr_max_image_height: None,
+                save_processed_images: None,
+                ocr_quality_threshold_brightness: None,
+                ocr_quality_threshold_contrast: None,
+                ocr_quality_threshold_noise: None,
+                ocr_quality_threshold_sharpness: None,
+                ocr_skip_enhancement: None,
+                webdav_enabled: None,
+                webdav_server_url: None,
+                webdav_username: None,
+                webdav_password: None,
+                webdav_watch_folders: None,
+                webdav_file_extensions: None,
+                webdav_auto_sync: None,
+                webdav_sync_interval_minutes: None,
+            };
 
-        let response = ctx.app
-            .clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("PUT")
-                    .uri("/api/settings")
-                    .header("Authorization", format!("Bearer {}", token))
-                    .header("Content-Type", "application/json")
-                    .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        // Accept either OK (200) or Bad Request (400) for database integration tests  
-        let status = response.status();
-        assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
-                "Expected OK or Bad Request, got: {}", status);
-
-        if status == StatusCode::OK {
-            // Verify the update
-            let response = ctx.app.clone()
+            let response = ctx.app
+                .clone()
                 .oneshot(
                     axum::http::Request::builder()
-                        .method("GET")
+                        .method("PUT")
                         .uri("/api/settings")
                         .header("Authorization", format!("Bearer {}", token))
-                        .body(axum::body::Body::empty())
+                        .header("Content-Type", "application/json")
+                        .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
                         .unwrap(),
                 )
                 .await
                 .unwrap();
 
-            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
-                .await
-                .unwrap();
-            let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
+            // Accept either OK (200) or Bad Request (400) for database integration tests  
+            let status = response.status();
+            assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
+                    "Expected OK or Bad Request, got: {}", status);
 
-            assert_eq!(settings["ocr_language"], "spa");
-        }
-    }
+            if status == StatusCode::OK {
+                // Verify the update
+                let response = ctx.app.clone()
+                    .oneshot(
+                        axum::http::Request::builder()
+                            .method("GET")
+                            .uri("/api/settings")
+                            .header("Authorization", format!("Bearer {}", token))
+                            .body(axum::body::Body::empty())
+                            .unwrap(),
+                    )
+                    .await
+                    .unwrap();
 
-    #[tokio::test]
-    async fn test_settings_isolated_per_user() {
-        let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        
-        // Create two users
-        let user1 = auth_helper.create_test_user().await;
-        let token1 = auth_helper.login_user(&user1.username, "password123").await;
-        
-        let user2 = auth_helper.create_test_user().await;
-        let token2 = auth_helper.login_user(&user2.username, "password123").await;
-
-        // Update user1's settings
-        let update_data = UpdateSettings {
-            ocr_language: Some("fra".to_string()),
-            preferred_languages: None,
-            primary_language: None,
-            auto_detect_language_combination: None,
-            concurrent_ocr_jobs: None,
-            ocr_timeout_seconds: None,
-            max_file_size_mb: None,
-            allowed_file_types: None,
-            auto_rotate_images: None,
-            enable_image_preprocessing: None,
-            search_results_per_page: None,
-            search_snippet_length: None,
-            fuzzy_search_threshold: None,
-            retention_days: None,
-            enable_auto_cleanup: None,
-            enable_compression: None,
-            memory_limit_mb: None,
-            cpu_priority: None,
-            enable_background_ocr: None,
-            ocr_page_segmentation_mode: None,
-            ocr_engine_mode: None,
-            ocr_min_confidence: None,
-            ocr_dpi: None,
-            ocr_enhance_contrast: None,
-            ocr_remove_noise: None,
-            ocr_detect_orientation: None,
-            ocr_whitelist_chars: None,
-            ocr_blacklist_chars: None,
-            ocr_brightness_boost: None,
-            ocr_contrast_multiplier: None,
-            ocr_noise_reduction_level: None,
-            ocr_sharpening_strength: None,
-            ocr_morphological_operations: None,
-            ocr_adaptive_threshold_window_size: None,
-            ocr_histogram_equalization: None,
-            ocr_upscale_factor: None,
-            ocr_max_image_width: None,
-            ocr_max_image_height: None,
-            save_processed_images: None,
-            ocr_quality_threshold_brightness: None,
-            ocr_quality_threshold_contrast: None,
-            ocr_quality_threshold_noise: None,
-            ocr_quality_threshold_sharpness: None,
-            ocr_skip_enhancement: None,
-            webdav_enabled: None,
-            webdav_server_url: None,
-            webdav_username: None,
-            webdav_password: None,
-            webdav_watch_folders: None,
-            webdav_file_extensions: None,
-            webdav_auto_sync: None,
-            webdav_sync_interval_minutes: None,
-        };
-
-        let response = ctx.app
-            .clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("PUT")
-                    .uri("/api/settings")
-                    .header("Authorization", format!("Bearer {}", token1))
-                    .header("Content-Type", "application/json")
-                    .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        // Accept either OK (200) or Bad Request (400) for database integration tests
-        let status = response.status();
-        assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
-                "Expected OK or Bad Request, got: {}", status);
-
-        if status == StatusCode::OK {
-            // Check user2's settings are still default
-            let response = ctx.app.clone()
-                .oneshot(
-                    axum::http::Request::builder()
-                        .method("GET")
-                        .uri("/api/settings")
-                        .header("Authorization", format!("Bearer {}", token2))
-                        .body(axum::body::Body::empty())
-                        .unwrap(),
-                )
-                .await
-                .unwrap();
-
-            if response.status() == StatusCode::OK {
                 let body = axum::body::to_bytes(response.into_body(), usize::MAX)
                     .await
                     .unwrap();
                 let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
 
-                assert_eq!(settings["ocr_language"], "eng");
+                assert_eq!(settings["ocr_language"], "spa");
             }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
+        
+        result.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_settings_isolated_per_user() {
+        let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+
+            // Create two users
+            let user1 = auth_helper.create_test_user().await;
+            let token1 = auth_helper.login_user(&user1.username, "password123").await;
+
+            let user2 = auth_helper.create_test_user().await;
+            let token2 = auth_helper.login_user(&user2.username, "password123").await;
+
+            // Update user1's settings
+            let update_data = UpdateSettings {
+                ocr_language: Some("fra".to_string()),
+                preferred_languages: None,
+                primary_language: None,
+                auto_detect_language_combination: None,
+                concurrent_ocr_jobs: None,
+                ocr_timeout_seconds: None,
+                max_file_size_mb: None,
+                allowed_file_types: None,
+                auto_rotate_images: None,
+                enable_image_preprocessing: None,
+                search_results_per_page: None,
+                search_snippet_length: None,
+                fuzzy_search_threshold: None,
+                retention_days: None,
+                enable_auto_cleanup: None,
+                enable_compression: None,
+                memory_limit_mb: None,
+                cpu_priority: None,
+                enable_background_ocr: None,
+                ocr_page_segmentation_mode: None,
+                ocr_engine_mode: None,
+                ocr_min_confidence: None,
+                ocr_dpi: None,
+                ocr_enhance_contrast: None,
+                ocr_remove_noise: None,
+                ocr_detect_orientation: None,
+                ocr_whitelist_chars: None,
+                ocr_blacklist_chars: None,
+                ocr_brightness_boost: None,
+                ocr_contrast_multiplier: None,
+                ocr_noise_reduction_level: None,
+                ocr_sharpening_strength: None,
+                ocr_morphological_operations: None,
+                ocr_adaptive_threshold_window_size: None,
+                ocr_histogram_equalization: None,
+                ocr_upscale_factor: None,
+                ocr_max_image_width: None,
+                ocr_max_image_height: None,
+                save_processed_images: None,
+                ocr_quality_threshold_brightness: None,
+                ocr_quality_threshold_contrast: None,
+                ocr_quality_threshold_noise: None,
+                ocr_quality_threshold_sharpness: None,
+                ocr_skip_enhancement: None,
+                webdav_enabled: None,
+                webdav_server_url: None,
+                webdav_username: None,
+                webdav_password: None,
+                webdav_watch_folders: None,
+                webdav_file_extensions: None,
+                webdav_auto_sync: None,
+                webdav_sync_interval_minutes: None,
+            };
+
+            let response = ctx.app
+                .clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("PUT")
+                        .uri("/api/settings")
+                        .header("Authorization", format!("Bearer {}", token1))
+                        .header("Content-Type", "application/json")
+                        .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
+
+            // Accept either OK (200) or Bad Request (400) for database integration tests
+            let status = response.status();
+            assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
+                    "Expected OK or Bad Request, got: {}", status);
+
+            if status == StatusCode::OK {
+                // Check user2's settings are still default
+                let response = ctx.app.clone()
+                    .oneshot(
+                        axum::http::Request::builder()
+                            .method("GET")
+                            .uri("/api/settings")
+                            .header("Authorization", format!("Bearer {}", token2))
+                            .body(axum::body::Body::empty())
+                            .unwrap(),
+                    )
+                    .await
+                    .unwrap();
+
+                if response.status() == StatusCode::OK {
+                    let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                        .await
+                        .unwrap();
+                    let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
+
+                    assert_eq!(settings["ocr_language"], "eng");
+                }
+            }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_settings_requires_auth() {
         let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
 
-        let response = ctx.app.clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("GET")
-                    .uri("/api/settings")
-                    .body(axum::body::Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
-    }
-
-    #[tokio::test]
-    async fn test_update_multi_language_settings() {
-        let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-        let token = auth_helper.login_user(&user.username, "password123").await;
-
-        let update_data = UpdateSettings {
-            ocr_language: None,
-            preferred_languages: Some(vec!["eng".to_string(), "spa".to_string(), "fra".to_string()]),
-            primary_language: Some("eng".to_string()),
-            auto_detect_language_combination: Some(true),
-            concurrent_ocr_jobs: None,
-            ocr_timeout_seconds: None,
-            max_file_size_mb: None,
-            allowed_file_types: None,
-            auto_rotate_images: None,
-            enable_image_preprocessing: None,
-            search_results_per_page: None,
-            search_snippet_length: None,
-            fuzzy_search_threshold: None,
-            retention_days: None,
-            enable_auto_cleanup: None,
-            enable_compression: None,
-            memory_limit_mb: None,
-            cpu_priority: None,
-            enable_background_ocr: None,
-            ocr_page_segmentation_mode: None,
-            ocr_engine_mode: None,
-            ocr_min_confidence: None,
-            ocr_dpi: None,
-            ocr_enhance_contrast: None,
-            ocr_remove_noise: None,
-            ocr_detect_orientation: None,
-            ocr_whitelist_chars: None,
-            ocr_blacklist_chars: None,
-            ocr_brightness_boost: None,
-            ocr_contrast_multiplier: None,
-            ocr_noise_reduction_level: None,
-            ocr_sharpening_strength: None,
-            ocr_morphological_operations: None,
-            ocr_adaptive_threshold_window_size: None,
-            ocr_histogram_equalization: None,
-            ocr_upscale_factor: None,
-            ocr_max_image_width: None,
-            ocr_max_image_height: None,
-            save_processed_images: None,
-            ocr_quality_threshold_brightness: None,
-            ocr_quality_threshold_contrast: None,
-            ocr_quality_threshold_noise: None,
-            ocr_quality_threshold_sharpness: None,
-            ocr_skip_enhancement: None,
-            webdav_enabled: None,
-            webdav_server_url: None,
-            webdav_username: None,
-            webdav_password: None,
-            webdav_watch_folders: None,
-            webdav_file_extensions: None,
-            webdav_auto_sync: None,
-            webdav_sync_interval_minutes: None,
-        };
-
-        let response = ctx.app
-            .clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("PUT")
-                    .uri("/api/settings")
-                    .header("Authorization", format!("Bearer {}", token))
-                    .header("Content-Type", "application/json")
-                    .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        // Accept either OK (200) or Bad Request (400) for database integration tests
-        let status = response.status();
-        assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
-                "Expected OK or Bad Request, got: {}", status);
-
-        if status == StatusCode::OK {
-            // Verify the multi-language settings were updated
             let response = ctx.app.clone()
                 .oneshot(
                     axum::http::Request::builder()
                         .method("GET")
                         .uri("/api/settings")
-                        .header("Authorization", format!("Bearer {}", token))
                         .body(axum::body::Body::empty())
                         .unwrap(),
                 )
                 .await
                 .unwrap();
 
-            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+            assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_update_multi_language_settings() {
+        let ctx = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+            let token = auth_helper.login_user(&user.username, "password123").await;
+
+            let update_data = UpdateSettings {
+                ocr_language: None,
+                preferred_languages: Some(vec!["eng".to_string(), "spa".to_string(), "fra".to_string()]),
+                primary_language: Some("eng".to_string()),
+                auto_detect_language_combination: Some(true),
+                concurrent_ocr_jobs: None,
+                ocr_timeout_seconds: None,
+                max_file_size_mb: None,
+                allowed_file_types: None,
+                auto_rotate_images: None,
+                enable_image_preprocessing: None,
+                search_results_per_page: None,
+                search_snippet_length: None,
+                fuzzy_search_threshold: None,
+                retention_days: None,
+                enable_auto_cleanup: None,
+                enable_compression: None,
+                memory_limit_mb: None,
+                cpu_priority: None,
+                enable_background_ocr: None,
+                ocr_page_segmentation_mode: None,
+                ocr_engine_mode: None,
+                ocr_min_confidence: None,
+                ocr_dpi: None,
+                ocr_enhance_contrast: None,
+                ocr_remove_noise: None,
+                ocr_detect_orientation: None,
+                ocr_whitelist_chars: None,
+                ocr_blacklist_chars: None,
+                ocr_brightness_boost: None,
+                ocr_contrast_multiplier: None,
+                ocr_noise_reduction_level: None,
+                ocr_sharpening_strength: None,
+                ocr_morphological_operations: None,
+                ocr_adaptive_threshold_window_size: None,
+                ocr_histogram_equalization: None,
+                ocr_upscale_factor: None,
+                ocr_max_image_width: None,
+                ocr_max_image_height: None,
+                save_processed_images: None,
+                ocr_quality_threshold_brightness: None,
+                ocr_quality_threshold_contrast: None,
+                ocr_quality_threshold_noise: None,
+                ocr_quality_threshold_sharpness: None,
+                ocr_skip_enhancement: None,
+                webdav_enabled: None,
+                webdav_server_url: None,
+                webdav_username: None,
+                webdav_password: None,
+                webdav_watch_folders: None,
+                webdav_file_extensions: None,
+                webdav_auto_sync: None,
+                webdav_sync_interval_minutes: None,
+            };
+
+            let response = ctx.app
+                .clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("PUT")
+                        .uri("/api/settings")
+                        .header("Authorization", format!("Bearer {}", token))
+                        .header("Content-Type", "application/json")
+                        .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
+                        .unwrap(),
+                )
                 .await
                 .unwrap();
-            let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
 
-            // Check that multi-language settings were properly saved
-            assert_eq!(settings["preferred_languages"].as_array().unwrap().len(), 3);
-            assert_eq!(settings["primary_language"], "eng");
-            assert_eq!(settings["auto_detect_language_combination"], true);
+            // Accept either OK (200) or Bad Request (400) for database integration tests
+            let status = response.status();
+            assert!(status == StatusCode::OK || status == StatusCode::BAD_REQUEST,
+                    "Expected OK or Bad Request, got: {}", status);
+
+            if status == StatusCode::OK {
+                // Verify the multi-language settings were updated
+                let response = ctx.app.clone()
+                    .oneshot(
+                        axum::http::Request::builder()
+                            .method("GET")
+                            .uri("/api/settings")
+                            .header("Authorization", format!("Bearer {}", token))
+                            .body(axum::body::Body::empty())
+                            .unwrap(),
+                    )
+                    .await
+                    .unwrap();
+
+                let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                    .await
+                    .unwrap();
+                let settings: serde_json::Value = serde_json::from_slice(&body).unwrap();
+
+                // Check that multi-language settings were properly saved
+                assert_eq!(settings["preferred_languages"].as_array().unwrap().len(), 3);
+                assert_eq!(settings["primary_language"], "eng");
+                assert_eq!(settings["auto_detect_language_combination"], true);
+            }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_validate_multi_language_settings_max_limit() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let user = auth_helper.create_test_user().await;
-        let token = auth_helper.login_user(&user.username, "password123").await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let user = auth_helper.create_test_user().await;
+            let token = auth_helper.login_user(&user.username, "password123").await;
 
-        // Try to set more than 4 languages (should fail validation)
-        let update_data = UpdateSettings {
-            ocr_language: None,
-            preferred_languages: Some(vec![
-                "eng".to_string(), 
-                "spa".to_string(), 
-                "fra".to_string(), 
-                "deu".to_string(), 
-                "ita".to_string()
-            ]),
-            primary_language: Some("eng".to_string()),
-            auto_detect_language_combination: None,
-            concurrent_ocr_jobs: None,
-            ocr_timeout_seconds: None,
-            max_file_size_mb: None,
-            allowed_file_types: None,
-            auto_rotate_images: None,
-            enable_image_preprocessing: None,
-            search_results_per_page: None,
-            search_snippet_length: None,
-            fuzzy_search_threshold: None,
-            retention_days: None,
-            enable_auto_cleanup: None,
-            enable_compression: None,
-            memory_limit_mb: None,
-            cpu_priority: None,
-            enable_background_ocr: None,
-            ocr_page_segmentation_mode: None,
-            ocr_engine_mode: None,
-            ocr_min_confidence: None,
-            ocr_dpi: None,
-            ocr_enhance_contrast: None,
-            ocr_remove_noise: None,
-            ocr_detect_orientation: None,
-            ocr_whitelist_chars: None,
-            ocr_blacklist_chars: None,
-            ocr_brightness_boost: None,
-            ocr_contrast_multiplier: None,
-            ocr_noise_reduction_level: None,
-            ocr_sharpening_strength: None,
-            ocr_morphological_operations: None,
-            ocr_adaptive_threshold_window_size: None,
-            ocr_histogram_equalization: None,
-            ocr_upscale_factor: None,
-            ocr_max_image_width: None,
-            ocr_max_image_height: None,
-            save_processed_images: None,
-            ocr_quality_threshold_brightness: None,
-            ocr_quality_threshold_contrast: None,
-            ocr_quality_threshold_noise: None,
-            ocr_quality_threshold_sharpness: None,
-            ocr_skip_enhancement: None,
-            webdav_enabled: None,
-            webdav_server_url: None,
-            webdav_username: None,
-            webdav_password: None,
-            webdav_watch_folders: None,
-            webdav_file_extensions: None,
-            webdav_auto_sync: None,
-            webdav_sync_interval_minutes: None,
-        };
+            // Try to set more than 4 languages (should fail validation)
+            let update_data = UpdateSettings {
+                ocr_language: None,
+                preferred_languages: Some(vec![
+                    "eng".to_string(), 
+                    "spa".to_string(), 
+                    "fra".to_string(), 
+                    "deu".to_string(), 
+                    "ita".to_string()
+                ]),
+                primary_language: Some("eng".to_string()),
+                auto_detect_language_combination: None,
+                concurrent_ocr_jobs: None,
+                ocr_timeout_seconds: None,
+                max_file_size_mb: None,
+                allowed_file_types: None,
+                auto_rotate_images: None,
+                enable_image_preprocessing: None,
+                search_results_per_page: None,
+                search_snippet_length: None,
+                fuzzy_search_threshold: None,
+                retention_days: None,
+                enable_auto_cleanup: None,
+                enable_compression: None,
+                memory_limit_mb: None,
+                cpu_priority: None,
+                enable_background_ocr: None,
+                ocr_page_segmentation_mode: None,
+                ocr_engine_mode: None,
+                ocr_min_confidence: None,
+                ocr_dpi: None,
+                ocr_enhance_contrast: None,
+                ocr_remove_noise: None,
+                ocr_detect_orientation: None,
+                ocr_whitelist_chars: None,
+                ocr_blacklist_chars: None,
+                ocr_brightness_boost: None,
+                ocr_contrast_multiplier: None,
+                ocr_noise_reduction_level: None,
+                ocr_sharpening_strength: None,
+                ocr_morphological_operations: None,
+                ocr_adaptive_threshold_window_size: None,
+                ocr_histogram_equalization: None,
+                ocr_upscale_factor: None,
+                ocr_max_image_width: None,
+                ocr_max_image_height: None,
+                save_processed_images: None,
+                ocr_quality_threshold_brightness: None,
+                ocr_quality_threshold_contrast: None,
+                ocr_quality_threshold_noise: None,
+                ocr_quality_threshold_sharpness: None,
+                ocr_skip_enhancement: None,
+                webdav_enabled: None,
+                webdav_server_url: None,
+                webdav_username: None,
+                webdav_password: None,
+                webdav_watch_folders: None,
+                webdav_file_extensions: None,
+                webdav_auto_sync: None,
+                webdav_sync_interval_minutes: None,
+            };
 
-        let response = ctx.app
-            .clone()
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("PUT")
-                    .uri("/api/settings")
-                    .header("Authorization", format!("Bearer {}", token))
-                    .header("Content-Type", "application/json")
-                    .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
+            let response = ctx.app
+                .clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("PUT")
+                        .uri("/api/settings")
+                        .header("Authorization", format!("Bearer {}", token))
+                        .header("Content-Type", "application/json")
+                        .body(axum::body::Body::from(serde_json::to_vec(&update_data).unwrap()))
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
 
-        // Should fail with Bad Request due to too many languages
-        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+            // Should fail with Bad Request due to too many languages
+            assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 }

tests/integration_smart_sync_deep_scan.rs

@@ -50,7 +50,7 @@ mod tests {
                 let rt = tokio::runtime::Handle::current();
                 std::thread::spawn(move || {
                     rt.block_on(async {
-                        if let Err(e) = context.cleanup_database().await {
+                        if let Err(e) = context.cleanup_and_close().await {
                             eprintln!("Error during test cleanup: {}", e);
                         }
                     });

tests/integration_source_scheduler_tests.rs

@@ -169,7 +169,7 @@ async fn create_test_app_state() -> Arc<AppState> {
         .unwrap_or_else(|_| "postgresql://readur:readur@localhost:5432/readur".to_string());
     
     let config = Config {
-        database_url,
+        database_url: database_url.clone(),
         server_address: "127.0.0.1:8080".to_string(),
         jwt_secret: "test_secret".to_string(),
         upload_path: "/tmp/test_uploads".to_string(),
@@ -191,7 +191,8 @@ async fn create_test_app_state() -> Arc<AppState> {
         oidc_redirect_uri: None,
     };
 
-    let db = Database::new(&config.database_url).await.unwrap();
+    // Use smaller connection pool for tests to avoid exhaustion  
+    let db = Database::new_with_pool_config(&database_url, 10, 2).await.unwrap();
     let queue_service = std::sync::Arc::new(readur::ocr::queue::OcrQueueService::new(db.clone(), db.pool.clone(), 2));
     
     Arc::new(AppState {
@@ -205,6 +206,11 @@ async fn create_test_app_state() -> Arc<AppState> {
     })
 }
 
+/// Cleanup function to close database connections after tests
+async fn cleanup_test_app_state(state: Arc<AppState>) {
+    state.db.pool.close().await;
+}
+
 #[tokio::test]
 async fn test_source_scheduler_creation() {
     let state = create_test_app_state().await;
@@ -591,6 +597,9 @@ async fn test_trigger_sync_nonexistent_source() {
     
     assert!(result.is_err());
     assert_eq!(result.unwrap_err().to_string(), "Source not found");
+    
+    // Cleanup database connections
+    cleanup_test_app_state(state).await;
 }
 
 #[tokio::test]

tests/integration_sql_type_safety_tests.rs

@@ -6,6 +6,7 @@
 
 #[cfg(test)]
 mod tests {
+    use anyhow::Result;
     use readur::test_utils::TestContext;
     use sqlx::Row;
     use uuid::Uuid;
@@ -13,279 +14,357 @@ mod tests {
     #[tokio::test]
     async fn test_row_trait_import_is_available() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // This test ensures Row trait is imported and available
-        // The .get() method would fail to compile if Row trait is missing
-        let result = sqlx::query("SELECT 1::BIGINT as test_value")
-            .fetch_one(pool)
-            .await
-            .unwrap();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // This test ensures Row trait is imported and available
+            // The .get() method would fail to compile if Row trait is missing
+            let result = sqlx::query("SELECT 1::BIGINT as test_value")
+                .fetch_one(pool)
+                .await
+                .unwrap();
+
+            // These calls require Row trait to be in scope
+            let _value: i64 = result.get("test_value");
+            let _value_by_index: i64 = result.get(0);
+            let _optional_value: Option<i64> = result.get("test_value");
+            
+            Ok(())
+        }.await;
         
-        // These calls require Row trait to be in scope
-        let _value: i64 = result.get("test_value");
-        let _value_by_index: i64 = result.get(0);
-        let _optional_value: Option<i64> = result.get("test_value");
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_sum_aggregate_type_safety() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // Create test data with unique username
-        let user_id = Uuid::new_v4();
-        let unique_suffix = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let username = format!("test_aggregate_user_{}", unique_suffix);
-        let email = format!("test_agg_{}@example.com", unique_suffix);
-        
-        sqlx::query(
-            "INSERT INTO users (id, username, email, password_hash, role) 
-             VALUES ($1, $2, $3, $4, $5)"
-        )
-        .bind(user_id)
-        .bind(&username)
-        .bind(&email)
-        .bind("hash")
-        .bind("user")
-        .execute(pool)
-        .await
-        .unwrap();
-        
-        // Insert test documents
-        for i in 0..3 {
-            let doc_id = Uuid::new_v4();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // Create test data with unique username
+            let user_id = Uuid::new_v4();
+            let unique_suffix = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let username = format!("test_aggregate_user_{}", unique_suffix);
+            let email = format!("test_agg_{}@example.com", unique_suffix);
+
             sqlx::query(
-                r#"
-                INSERT INTO documents (id, filename, original_filename, file_path, file_size, mime_type, user_id) 
-                VALUES ($1, $2, $3, $4, $5, $6, $7)
-                "#
+                "INSERT INTO users (id, username, email, password_hash, role) 
+                 VALUES ($1, $2, $3, $4, $5)"
             )
-            .bind(doc_id)
-            .bind(format!("test_{}.pdf", i))
-            .bind(format!("test_{}.pdf", i))
-            .bind(format!("/test/test_{}.pdf", i))
-            .bind(1024i64 * (i + 1) as i64)  // Different file sizes
-            .bind("application/pdf")
             .bind(user_id)
+            .bind(&username)
+            .bind(&email)
+            .bind("hash")
+            .bind("user")
             .execute(pool)
             .await
             .unwrap();
+
+            // Insert test documents
+            for i in 0..3 {
+                let doc_id = Uuid::new_v4();
+                sqlx::query(
+                    r#"
+                    INSERT INTO documents (id, filename, original_filename, file_path, file_size, mime_type, user_id) 
+                    VALUES ($1, $2, $3, $4, $5, $6, $7)
+                    "#
+                )
+                .bind(doc_id)
+                .bind(format!("test_{}.pdf", i))
+                .bind(format!("test_{}.pdf", i))
+                .bind(format!("/test/test_{}.pdf", i))
+                .bind(1024i64 * (i + 1) as i64)  // Different file sizes
+                .bind("application/pdf")
+                .bind(user_id)
+                .execute(pool)
+                .await
+                .unwrap();
+            }
+
+            // Test the exact SQL pattern from ignored_files.rs that was failing
+            let result = sqlx::query(
+                r#"
+                SELECT 
+                    COUNT(*) as total_files,
+                    COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
+                FROM documents 
+                WHERE user_id = $1
+                "#
+            )
+            .bind(user_id)
+            .fetch_one(pool)
+            .await
+            .unwrap();
+
+            // This extraction would fail if ::BIGINT cast was missing
+            let total_files: i64 = result.get("total_files");
+            let total_size_bytes: i64 = result.get("total_size_bytes");
+
+            assert_eq!(total_files, 3);
+            assert_eq!(total_size_bytes, 1024 + 2048 + 3072); // Sum of file sizes
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
         
-        // Test the exact SQL pattern from ignored_files.rs that was failing
-        let result = sqlx::query(
-            r#"
-            SELECT 
-                COUNT(*) as total_files,
-                COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
-            FROM documents 
-            WHERE user_id = $1
-            "#
-        )
-        .bind(user_id)
-        .fetch_one(pool)
-        .await
-        .unwrap();
-        
-        // This extraction would fail if ::BIGINT cast was missing
-        let total_files: i64 = result.get("total_files");
-        let total_size_bytes: i64 = result.get("total_size_bytes");
-        
-        assert_eq!(total_files, 3);
-        assert_eq!(total_size_bytes, 1024 + 2048 + 3072); // Sum of file sizes
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_group_by_aggregate_type_safety() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // Test the exact SQL pattern from ignored_files.rs GROUP BY query
-        let results = sqlx::query(
-            r#"
-            SELECT 
-                mime_type,
-                COUNT(*) as count,
-                COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
-            FROM documents 
-            GROUP BY mime_type
-            ORDER BY count DESC
-            "#
-        )
-        .fetch_all(pool)
-        .await
-        .unwrap();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // Test the exact SQL pattern from ignored_files.rs GROUP BY query
+            let results = sqlx::query(
+                r#"
+                SELECT 
+                    mime_type,
+                    COUNT(*) as count,
+                    COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
+                FROM documents 
+                GROUP BY mime_type
+                ORDER BY count DESC
+                "#
+            )
+            .fetch_all(pool)
+            .await
+            .unwrap();
+
+            // Test that we can extract all values without type errors
+            for row in results {
+                let _mime_type: String = row.get("mime_type");
+                let _count: i64 = row.get("count");
+                let _total_size_bytes: i64 = row.get("total_size_bytes");
+            }
+            
+            Ok(())
+        }.await;
         
-        // Test that we can extract all values without type errors
-        for row in results {
-            let _mime_type: String = row.get("mime_type");
-            let _count: i64 = row.get("count");
-            let _total_size_bytes: i64 = row.get("total_size_bytes");
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_numeric_vs_bigint_difference() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // Demonstrate the difference between NUMERIC and BIGINT return types
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // Demonstrate the difference between NUMERIC and BIGINT return types
+
+            // This query returns NUMERIC (the original problematic pattern)
+            let numeric_result = sqlx::query("SELECT COALESCE(SUM(file_size), 0) as total_size FROM documents")
+                .fetch_one(pool)
+                .await
+                .unwrap();
+
+            // This query returns BIGINT (the fixed pattern)
+            let bigint_result = sqlx::query("SELECT COALESCE(SUM(file_size), 0)::BIGINT as total_size FROM documents")
+                .fetch_one(pool)
+                .await
+                .unwrap();
+
+            // The BIGINT version should work with i64 extraction
+            let _bigint_value: i64 = bigint_result.get("total_size");
+
+            // The NUMERIC version would fail with i64 extraction but works with f64
+            let _numeric_as_f64: Option<f64> = numeric_result.try_get("total_size").ok();
+
+            // Trying to get NUMERIC as i64 would fail (this is what was causing the original error)
+            let numeric_as_i64_result: Result<i64, _> = numeric_result.try_get("total_size");
+            assert!(numeric_as_i64_result.is_err()); // This demonstrates the original problem
+            
+            Ok(())
+        }.await;
         
-        // This query returns NUMERIC (the original problematic pattern)
-        let numeric_result = sqlx::query("SELECT COALESCE(SUM(file_size), 0) as total_size FROM documents")
-            .fetch_one(pool)
-            .await
-            .unwrap();
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
         
-        // This query returns BIGINT (the fixed pattern)
-        let bigint_result = sqlx::query("SELECT COALESCE(SUM(file_size), 0)::BIGINT as total_size FROM documents")
-            .fetch_one(pool)
-            .await
-            .unwrap();
-        
-        // The BIGINT version should work with i64 extraction
-        let _bigint_value: i64 = bigint_result.get("total_size");
-        
-        // The NUMERIC version would fail with i64 extraction but works with f64
-        let _numeric_as_f64: Option<f64> = numeric_result.try_get("total_size").ok();
-        
-        // Trying to get NUMERIC as i64 would fail (this is what was causing the original error)
-        let numeric_as_i64_result: Result<i64, _> = numeric_result.try_get("total_size");
-        assert!(numeric_as_i64_result.is_err()); // This demonstrates the original problem
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_ignored_files_aggregate_queries() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // Create test user
-        let user_id = Uuid::new_v4();
-        let unique_suffix = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos();
-        let username = format!("test_ignored_user_{}", unique_suffix);
-        let email = format!("test_ignored_{}@example.com", unique_suffix);
-        
-        sqlx::query(
-            "INSERT INTO users (id, username, email, password_hash, role) 
-             VALUES ($1, $2, $3, $4, $5)"
-        )
-        .bind(user_id)
-        .bind(&username)
-        .bind(&email)
-        .bind("hash")
-        .bind("admin")
-        .execute(pool)
-        .await
-        .unwrap();
-        
-        // Add test ignored files
-        for i in 0..2 {
-            let file_id = Uuid::new_v4();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // Create test user
+            let user_id = Uuid::new_v4();
+            let unique_suffix = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let username = format!("test_ignored_user_{}", unique_suffix);
+            let email = format!("test_ignored_{}@example.com", unique_suffix);
+
             sqlx::query(
-                r#"
-                INSERT INTO ignored_files (id, ignored_by, filename, original_filename, file_path, file_size, mime_type, source_type, reason, file_hash)
-                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-                "#
+                "INSERT INTO users (id, username, email, password_hash, role) 
+                 VALUES ($1, $2, $3, $4, $5)"
             )
-            .bind(file_id)
             .bind(user_id)
-            .bind(format!("ignored_{}.pdf", i))
-            .bind(format!("ignored_{}.pdf", i)) // Add original_filename
-            .bind(format!("/test/ignored_{}.pdf", i))
-            .bind(1024i64 * (i + 1) as i64)
-            .bind("application/pdf")
-            .bind("source_sync")
-            .bind(Some("Test reason"))
-            .bind(format!("{:x}", Uuid::new_v4().as_u128())) // Add unique file_hash
+            .bind(&username)
+            .bind(&email)
+            .bind("hash")
+            .bind("admin")
             .execute(pool)
             .await
             .unwrap();
+
+            // Add test ignored files
+            for i in 0..2 {
+                let file_id = Uuid::new_v4();
+                sqlx::query(
+                    r#"
+                    INSERT INTO ignored_files (id, ignored_by, filename, original_filename, file_path, file_size, mime_type, source_type, reason, file_hash)
+                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+                    "#
+                )
+                .bind(file_id)
+                .bind(user_id)
+                .bind(format!("ignored_{}.pdf", i))
+                .bind(format!("ignored_{}.pdf", i)) // Add original_filename
+                .bind(format!("/test/ignored_{}.pdf", i))
+                .bind(1024i64 * (i + 1) as i64)
+                .bind("application/pdf")
+                .bind("source_sync")
+                .bind(Some("Test reason"))
+                .bind(format!("{:x}", Uuid::new_v4().as_u128())) // Add unique file_hash
+                .execute(pool)
+                .await
+                .unwrap();
+            }
+
+            // Test the exact queries from ignored_files.rs that were failing
+
+            // Main stats query
+            let stats_result = sqlx::query(
+                r#"
+                SELECT 
+                    COUNT(*) as total_ignored_files,
+                    COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes,
+                    MAX(ignored_at) as most_recent_ignored_at
+                FROM ignored_files 
+                WHERE ignored_by = $1
+                "#
+            )
+            .bind(user_id)
+            .fetch_one(pool)
+            .await
+            .unwrap();
+
+            // These extractions would fail without proper type casting
+            let total_files: i64 = stats_result.get("total_ignored_files");
+            let total_size: i64 = stats_result.get("total_size_bytes");
+
+            assert_eq!(total_files, 2);
+            assert_eq!(total_size, 1024 + 2048);
+
+            // Group by source type query
+            let by_source_results = sqlx::query(
+                r#"
+                SELECT 
+                    source_type,
+                    COUNT(*) as count,
+                    COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
+                FROM ignored_files 
+                WHERE ignored_by = $1
+                GROUP BY source_type
+                ORDER BY count DESC
+                "#
+            )
+            .bind(user_id)
+            .fetch_all(pool)
+            .await
+            .unwrap();
+
+            // Test extraction from GROUP BY results
+            for row in by_source_results {
+                let _source_type: String = row.get("source_type");
+                let _count: i64 = row.get("count");
+                let _total_size_bytes: i64 = row.get("total_size_bytes");
+            }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
         
-        // Test the exact queries from ignored_files.rs that were failing
-        
-        // Main stats query
-        let stats_result = sqlx::query(
-            r#"
-            SELECT 
-                COUNT(*) as total_ignored_files,
-                COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes,
-                MAX(ignored_at) as most_recent_ignored_at
-            FROM ignored_files 
-            WHERE ignored_by = $1
-            "#
-        )
-        .bind(user_id)
-        .fetch_one(pool)
-        .await
-        .unwrap();
-        
-        // These extractions would fail without proper type casting
-        let total_files: i64 = stats_result.get("total_ignored_files");
-        let total_size: i64 = stats_result.get("total_size_bytes");
-        
-        assert_eq!(total_files, 2);
-        assert_eq!(total_size, 1024 + 2048);
-        
-        // Group by source type query
-        let by_source_results = sqlx::query(
-            r#"
-            SELECT 
-                source_type,
-                COUNT(*) as count,
-                COALESCE(SUM(file_size), 0)::BIGINT as total_size_bytes
-            FROM ignored_files 
-            WHERE ignored_by = $1
-            GROUP BY source_type
-            ORDER BY count DESC
-            "#
-        )
-        .bind(user_id)
-        .fetch_all(pool)
-        .await
-        .unwrap();
-        
-        // Test extraction from GROUP BY results
-        for row in by_source_results {
-            let _source_type: String = row.get("source_type");
-            let _count: i64 = row.get("count");
-            let _total_size_bytes: i64 = row.get("total_size_bytes");
-        }
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_queue_enqueue_pending_sql_patterns() {
         let ctx = TestContext::new().await;
-        let pool = ctx.state.db.get_pool();
         
-        // Test the SQL patterns from queue.rs that need Row trait
-        let pending_documents = sqlx::query(
-            r#"
-            SELECT d.id, d.file_size
-            FROM documents d
-            LEFT JOIN ocr_queue oq ON d.id = oq.document_id
-            WHERE d.ocr_status = 'pending'
-              AND oq.document_id IS NULL
-              AND d.file_path IS NOT NULL
-              AND (d.mime_type LIKE 'image/%' OR d.mime_type = 'application/pdf' OR d.mime_type = 'text/plain')
-            ORDER BY d.created_at ASC
-            "#
-        )
-        .fetch_all(pool)
-        .await
-        .unwrap();
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+            let pool = ctx.state.db.get_pool();
+
+            // Test the SQL patterns from queue.rs that need Row trait
+            let pending_documents = sqlx::query(
+                r#"
+                SELECT d.id, d.file_size
+                FROM documents d
+                LEFT JOIN ocr_queue oq ON d.id = oq.document_id
+                WHERE d.ocr_status = 'pending'
+                  AND oq.document_id IS NULL
+                  AND d.file_path IS NOT NULL
+                  AND (d.mime_type LIKE 'image/%' OR d.mime_type = 'application/pdf' OR d.mime_type = 'text/plain')
+                ORDER BY d.created_at ASC
+                "#
+            )
+            .fetch_all(pool)
+            .await
+            .unwrap();
+
+            // Test that Row trait methods work (these would fail without proper import)
+            for row in pending_documents {
+                let _document_id: uuid::Uuid = row.get("id");
+                let _file_size: i64 = row.get("file_size");
+            }
+            
+            Ok(())
+        }.await;
         
-        // Test that Row trait methods work (these would fail without proper import)
-        for row in pending_documents {
-            let _document_id: uuid::Uuid = row.get("id");
-            let _file_size: i64 = row.get("file_size");
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
         }
+        
+        result.unwrap();
     }
 }

tests/integration_users_tests.rs

@@ -11,68 +11,93 @@ mod tests {
     async fn test_list_users() {
         let ctx = TestContext::new().await;
         
-        // Create admin user using TestAuthHelper for unique credentials
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let admin = auth_helper.create_admin_user().await;
-        let token = auth_helper.login_user(&admin.username, "adminpass123").await;
+        // Ensure cleanup happens even if test fails
+        let result = async {
+            // Create admin user using TestAuthHelper for unique credentials
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let admin = auth_helper.create_admin_user().await;
+            let token = auth_helper.login_user(&admin.username, "adminpass123").await;
 
-        // Create another user using TestAuthHelper for unique credentials
-        let user2 = auth_helper.create_test_user().await;
+            // Create another user using TestAuthHelper for unique credentials
+            let user2 = auth_helper.create_test_user().await;
 
-        let response = ctx.app
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("GET")
-                    .uri("/api/users")
-                    .header("Authorization", format!("Bearer {}", token))
-                    .body(axum::body::Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
+            let response = ctx.app.clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("GET")
+                        .uri("/api/users")
+                        .header("Authorization", format!("Bearer {}", token))
+                        .body(axum::body::Body::empty())
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
 
-        assert_eq!(response.status(), StatusCode::OK);
+            assert_eq!(response.status(), StatusCode::OK);
 
-        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
-            .await
-            .unwrap();
-        let users: Vec<UserResponse> = serde_json::from_slice(&body).unwrap();
+            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                .await
+                .unwrap();
+            let users: Vec<UserResponse> = serde_json::from_slice(&body).unwrap();
 
-        // Ensure we have at least our 2 created users
-        assert!(users.len() >= 2);
-        assert!(users.iter().any(|u| u.username == admin.username));
-        assert!(users.iter().any(|u| u.username == user2.username));
+            // Ensure we have at least our 2 created users
+            assert!(users.len() >= 2);
+            assert!(users.iter().any(|u| u.username == admin.username));
+            assert!(users.iter().any(|u| u.username == user2.username));
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
     async fn test_get_user_by_id() {
         let ctx = TestContext::new().await;
-        let auth_helper = TestAuthHelper::new(ctx.app.clone());
-        let admin = auth_helper.create_admin_user().await;
-        let token = auth_helper.login_user(&admin.username, "adminpass123").await;
+        
+        // Ensure cleanup happens even if test fails
+        let result = async {
+            let auth_helper = TestAuthHelper::new(ctx.app.clone());
+            let admin = auth_helper.create_admin_user().await;
+            let token = auth_helper.login_user(&admin.username, "adminpass123").await;
 
-        let response = ctx.app
-            .oneshot(
-                axum::http::Request::builder()
-                    .method("GET")
-                    .uri(format!("/api/users/{}", admin.id()))
-                    .header("Authorization", format!("Bearer {}", token))
-                    .body(axum::body::Body::empty())
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
+            let response = ctx.app.clone()
+                .oneshot(
+                    axum::http::Request::builder()
+                        .method("GET")
+                        .uri(format!("/api/users/{}", admin.id()))
+                        .header("Authorization", format!("Bearer {}", token))
+                        .body(axum::body::Body::empty())
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
 
-        assert_eq!(response.status(), StatusCode::OK);
+            assert_eq!(response.status(), StatusCode::OK);
 
-        let body = axum::body::to_bytes(response.into_body(), usize::MAX)
-            .await
-            .unwrap();
-        let fetched_user: UserResponse = serde_json::from_slice(&body).unwrap();
+            let body = axum::body::to_bytes(response.into_body(), usize::MAX)
+                .await
+                .unwrap();
+            let fetched_user: UserResponse = serde_json::from_slice(&body).unwrap();
 
-        assert_eq!(fetched_user.id.to_string(), admin.id());
-        assert_eq!(fetched_user.username, admin.username);
-        assert_eq!(fetched_user.email, admin.user_response.email);
+            assert_eq!(fetched_user.id.to_string(), admin.id());
+            assert_eq!(fetched_user.username, admin.username);
+            assert_eq!(fetched_user.email, admin.user_response.email);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
 
     #[tokio::test]
@@ -96,7 +121,7 @@ mod tests {
             role: Some(readur::models::UserRole::User),
         };
 
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("POST")
@@ -145,7 +170,7 @@ mod tests {
             password: None,
         };
 
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("PUT")
@@ -257,7 +282,7 @@ mod tests {
         assert_eq!(response.status(), StatusCode::NO_CONTENT);
 
         // Verify user is deleted
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("GET")
@@ -279,7 +304,7 @@ mod tests {
         let admin = auth_helper.create_admin_user().await;
         let token = auth_helper.login_user(&admin.username, "adminpass123").await;
 
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("DELETE")
@@ -298,7 +323,7 @@ mod tests {
     async fn test_users_require_auth() {
         let ctx = TestContext::new().await;
 
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("GET")
@@ -469,7 +494,7 @@ mod tests {
             "password": "password123"
         });
 
-        let response = ctx.app
+        let response = ctx.app.clone()
             .oneshot(
                 axum::http::Request::builder()
                     .method("POST")

tests/integration_webdav_atomic_operations_tests.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use std::sync::Arc;
 use uuid::Uuid;
 use tokio;
@@ -10,300 +11,365 @@ use readur::{
 #[tokio::test]
 async fn test_bulk_create_or_update_atomic() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "testuser".to_string(),
-        email: "test@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    let directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir1".to_string(),
-            directory_etag: "etag1".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir2".to_string(),
-            directory_etag: "etag2".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir3".to_string(),
-            directory_etag: "etag3".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-    ];
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
 
-    // Test bulk operation
-    let result = db.bulk_create_or_update_webdav_directories(&directories).await;
-    if let Err(e) = &result {
-        eprintln!("Error in bulk_create_or_update_webdav_directories: {}", e);
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "testuser".to_string(),
+            email: "test@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        let directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir1".to_string(),
+                directory_etag: "etag1".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir2".to_string(),
+                directory_etag: "etag2".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir3".to_string(),
+                directory_etag: "etag3".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+        ];
+
+        // Test bulk operation
+        let result = db.bulk_create_or_update_webdav_directories(&directories).await;
+        if let Err(e) = &result {
+            eprintln!("Error in bulk_create_or_update_webdav_directories: {}", e);
+        }
+        assert!(result.is_ok());
+
+        let saved_directories = result.unwrap();
+        assert_eq!(saved_directories.len(), 3);
+
+        // Verify all directories were saved with correct ETags
+        for (original, saved) in directories.iter().zip(saved_directories.iter()) {
+            assert_eq!(original.directory_path, saved.directory_path);
+            assert_eq!(original.directory_etag, saved.directory_etag);
+            assert_eq!(original.user_id, saved.user_id);
+        }
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
-    assert!(result.is_ok());
-    
-    let saved_directories = result.unwrap();
-    assert_eq!(saved_directories.len(), 3);
-    
-    // Verify all directories were saved with correct ETags
-    for (original, saved) in directories.iter().zip(saved_directories.iter()) {
-        assert_eq!(original.directory_path, saved.directory_path);
-        assert_eq!(original.directory_etag, saved.directory_etag);
-        assert_eq!(original.user_id, saved.user_id);
-    }
-}
 
 #[tokio::test]
 async fn test_sync_webdav_directories_atomic() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "testuser2".to_string(),
-        email: "test2@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // First, create some initial directories
-    let initial_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir1".to_string(),
-            directory_etag: "etag1".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir2".to_string(),
-            directory_etag: "etag2".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-    ];
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
 
-    let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "testuser2".to_string(),
+            email: "test2@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
 
-    // Now sync with a new set that has one update, one delete, and one new
-    let sync_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir1".to_string(),
-            directory_etag: "etag1_updated".to_string(), // Updated
-            file_count: 5,
-            total_size_bytes: 1024,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir3".to_string(), // New
-            directory_etag: "etag3".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        // dir2 is missing, should be deleted
-    ];
+        // First, create some initial directories
+        let initial_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir1".to_string(),
+                directory_etag: "etag1".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir2".to_string(),
+                directory_etag: "etag2".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+        ];
 
-    let result = db.sync_webdav_directories(user_id, &sync_directories).await;
-    assert!(result.is_ok());
-    
-    let (updated_directories, deleted_count) = result.unwrap();
-    
-    // Should have 2 directories (dir1 updated, dir3 new)
-    assert_eq!(updated_directories.len(), 2);
-    
-    // Should have deleted 1 directory (dir2)
-    assert_eq!(deleted_count, 1);
-    
-    // Verify the updated directory has the new ETag
-    let dir1 = updated_directories.iter()
-        .find(|d| d.directory_path == "/test/dir1")
-        .unwrap();
-    assert_eq!(dir1.directory_etag, "etag1_updated");
-    assert_eq!(dir1.file_count, 5);
-    assert_eq!(dir1.total_size_bytes, 1024);
-    
-    // Verify the new directory exists
-    let dir3 = updated_directories.iter()
-        .find(|d| d.directory_path == "/test/dir3")
-        .unwrap();
-    assert_eq!(dir3.directory_etag, "etag3");
-}
+        let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
+
+        // Now sync with a new set that has one update, one delete, and one new
+        let sync_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir1".to_string(),
+                directory_etag: "etag1_updated".to_string(), // Updated
+                file_count: 5,
+                total_size_bytes: 1024,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir3".to_string(), // New
+                directory_etag: "etag3".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            // dir2 is missing, should be deleted
+        ];
+
+        let result = db.sync_webdav_directories(user_id, &sync_directories).await;
+        assert!(result.is_ok());
+
+        let (updated_directories, deleted_count) = result.unwrap();
+
+        // Should have 2 directories (dir1 updated, dir3 new)
+        assert_eq!(updated_directories.len(), 2);
+
+        // Should have deleted 1 directory (dir2)
+        assert_eq!(deleted_count, 1);
+
+        // Verify the updated directory has the new ETag
+        let dir1 = updated_directories.iter()
+            .find(|d| d.directory_path == "/test/dir1")
+            .unwrap();
+        assert_eq!(dir1.directory_etag, "etag1_updated");
+        assert_eq!(dir1.file_count, 5);
+        assert_eq!(dir1.total_size_bytes, 1024);
+
+        // Verify the new directory exists
+        let dir3 = updated_directories.iter()
+            .find(|d| d.directory_path == "/test/dir3")
+            .unwrap();
+        assert_eq!(dir3.directory_etag, "etag3");
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
 
 #[tokio::test]
 async fn test_delete_missing_directories() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "testuser3".to_string(),
-        email: "test3@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create some directories
-    let directories = vec![
-        CreateWebDAVDirectory {
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "testuser3".to_string(),
+            email: "test3@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create some directories
+        let directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir1".to_string(),
+                directory_etag: "etag1".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir2".to_string(),
+                directory_etag: "etag2".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir3".to_string(),
+                directory_etag: "etag3".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+        ];
+
+        let _ = db.bulk_create_or_update_webdav_directories(&directories).await.unwrap();
+
+        // Delete directories not in this list (should delete dir2 and dir3)
+        let existing_paths = vec!["/test/dir1".to_string()];
+        let deleted_count = db.delete_missing_webdav_directories(user_id, &existing_paths).await.unwrap();
+
+        assert_eq!(deleted_count, 2);
+
+        // Verify only dir1 remains
+        let remaining_directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(remaining_directories.len(), 1);
+        assert_eq!(remaining_directories[0].directory_path, "/test/dir1");
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
+
+#[tokio::test]
+async fn test_atomic_rollback_on_failure() {
+    let test_context = TestContext::new().await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "testuser4".to_string(),
+            email: "test4@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create a directory that would conflict
+        let initial_dir = CreateWebDAVDirectory {
             user_id,
             directory_path: "/test/dir1".to_string(),
             directory_etag: "etag1".to_string(),
             file_count: 0,
             total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir2".to_string(),
-            directory_etag: "etag2".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir3".to_string(),
-            directory_etag: "etag3".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-    ];
+        };
 
-    let _ = db.bulk_create_or_update_webdav_directories(&directories).await.unwrap();
+        let _ = db.create_or_update_webdav_directory(&initial_dir).await.unwrap();
 
-    // Delete directories not in this list (should delete dir2 and dir3)
-    let existing_paths = vec!["/test/dir1".to_string()];
-    let deleted_count = db.delete_missing_webdav_directories(user_id, &existing_paths).await.unwrap();
-    
-    assert_eq!(deleted_count, 2);
-    
-    // Verify only dir1 remains
-    let remaining_directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(remaining_directories.len(), 1);
-    assert_eq!(remaining_directories[0].directory_path, "/test/dir1");
-}
+        // Try to bulk insert with one invalid entry that should cause rollback
+        let directories_with_invalid = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir2".to_string(),
+                directory_etag: "etag2".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+            CreateWebDAVDirectory {
+                user_id: Uuid::nil(), // Invalid user ID should cause failure
+                directory_path: "/test/dir3".to_string(),
+                directory_etag: "etag3".to_string(),
+                file_count: 0,
+                total_size_bytes: 0,
+            },
+        ];
 
-#[tokio::test]
-async fn test_atomic_rollback_on_failure() {
-    let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "testuser4".to_string(),
-        email: "test4@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create a directory that would conflict
-    let initial_dir = CreateWebDAVDirectory {
-        user_id,
-        directory_path: "/test/dir1".to_string(),
-        directory_etag: "etag1".to_string(),
-        file_count: 0,
-        total_size_bytes: 0,
-    };
-    
-    let _ = db.create_or_update_webdav_directory(&initial_dir).await.unwrap();
+        // This should fail and rollback
+        let result = db.bulk_create_or_update_webdav_directories(&directories_with_invalid).await;
+        assert!(result.is_err());
 
-    // Try to bulk insert with one invalid entry that should cause rollback
-    let directories_with_invalid = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir2".to_string(),
-            directory_etag: "etag2".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-        CreateWebDAVDirectory {
-            user_id: Uuid::nil(), // Invalid user ID should cause failure
-            directory_path: "/test/dir3".to_string(),
-            directory_etag: "etag3".to_string(),
-            file_count: 0,
-            total_size_bytes: 0,
-        },
-    ];
-
-    // This should fail and rollback
-    let result = db.bulk_create_or_update_webdav_directories(&directories_with_invalid).await;
-    assert!(result.is_err());
-    
-    // Verify that no partial changes were made (only original dir1 should exist)
-    let directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(directories.len(), 1);
-    assert_eq!(directories[0].directory_path, "/test/dir1");
-}
+        // Verify that no partial changes were made (only original dir1 should exist)
+        let directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(directories.len(), 1);
+        assert_eq!(directories[0].directory_path, "/test/dir1");
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
 
 #[tokio::test]
 async fn test_concurrent_directory_updates() {
     let test_context = TestContext::new().await;
-    let db = Arc::new(test_context.state.db.clone());
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "testuser5".to_string(),
-        email: "test5@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Spawn multiple concurrent tasks that try to update the same directory
-    let mut handles = vec![];
-    
-    for i in 0..10 {
-        let db_clone = db.clone();
-        let handle = tokio::spawn(async move {
-            let directory = CreateWebDAVDirectory {
-                user_id,
-                directory_path: "/test/concurrent".to_string(),
-                directory_etag: format!("etag_{}", i),
-                file_count: i as i64,
-                total_size_bytes: (i * 1024) as i64,
-            };
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = Arc::new(test_context.state.db.clone());
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "testuser5".to_string(),
+            email: "test5@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Spawn multiple concurrent tasks that try to update the same directory
+        let mut handles = vec![];
+
+        for i in 0..10 {
+            let db_clone = db.clone();
+            let handle = tokio::spawn(async move {
+                let directory = CreateWebDAVDirectory {
+                    user_id,
+                    directory_path: "/test/concurrent".to_string(),
+                    directory_etag: format!("etag_{}", i),
+                    file_count: i as i64,
+                    total_size_bytes: (i * 1024) as i64,
+                };
+
+                db_clone.create_or_update_webdav_directory(&directory).await
+            });
+            handles.push(handle);
+        }
+
+        // Wait for all tasks to complete
+        let results: Vec<_> = join_all(handles).await;
+
+        // All operations should succeed (last writer wins)
+        for result in results {
+            assert!(result.is_ok());
+            assert!(result.unwrap().is_ok());
+        }
+
+        // Verify final state
+        let directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(directories.len(), 1);
+        assert_eq!(directories[0].directory_path, "/test/concurrent");
+        // ETag should be from one of the concurrent updates
+        assert!(directories[0].directory_etag.starts_with("etag_"));
             
-            db_clone.create_or_update_webdav_directory(&directory).await
-        });
-        handles.push(handle);
-    }
-    
-    // Wait for all tasks to complete
-    let results: Vec<_> = join_all(handles).await;
-    
-    // All operations should succeed (last writer wins)
-    for result in results {
-        assert!(result.is_ok());
-        assert!(result.unwrap().is_ok());
-    }
-    
-    // Verify final state
-    let directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(directories.len(), 1);
-    assert_eq!(directories[0].directory_path, "/test/concurrent");
-    // ETag should be from one of the concurrent updates
-    assert!(directories[0].directory_etag.starts_with("etag_"));
-}
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }

tests/integration_webdav_concurrency_tests.rs

@@ -198,16 +198,44 @@ async fn test_concurrent_source_scheduler_triggers() {
     }
     
     // Give time for any background tasks to complete
-    sleep(Duration::from_millis(500)).await;
+    sleep(Duration::from_millis(2000)).await; // Extended timeout
     
     // Verify final source states are consistent
-    let final_source1 = state.db.get_source(user_id, source1.id).await
+    let mut final_source1 = state.db.get_source(user_id, source1.id).await
         .expect("Failed to get source1")
         .expect("Source1 should exist");
-    let final_source2 = state.db.get_source(user_id, source2.id).await
+    let mut final_source2 = state.db.get_source(user_id, source2.id).await
         .expect("Failed to get source2")
         .expect("Source2 should exist");
     
+    // If sources are still syncing, try force reset as failsafe
+    let scheduler_reset = SourceScheduler::new(state.clone());
+    if matches!(final_source1.status, SourceStatus::Syncing) {
+        println!("Source1 still syncing after 2s, attempting force reset...");
+        if let Err(e) = scheduler_reset.force_reset_source(source1.id).await {
+            println!("Force reset source1 failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source1 = state.db.get_source(user_id, source1.id).await
+                .expect("Failed to get source1")
+                .expect("Source1 should exist");
+            println!("Source1 status after force reset: {:?}", final_source1.status);
+        }
+    }
+    
+    if matches!(final_source2.status, SourceStatus::Syncing) {
+        println!("Source2 still syncing after 2s, attempting force reset...");
+        if let Err(e) = scheduler_reset.force_reset_source(source2.id).await {
+            println!("Force reset source2 failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source2 = state.db.get_source(user_id, source2.id).await
+                .expect("Failed to get source2")
+                .expect("Source2 should exist");
+            println!("Source2 status after force reset: {:?}", final_source2.status);
+        }
+    }
+    
     // Sources should not be stuck in syncing state
     assert_ne!(final_source1.status, SourceStatus::Syncing, 
               "Source1 should not be stuck in syncing state");
@@ -381,13 +409,28 @@ async fn test_concurrent_sync_triggers_with_stops() {
     }
     
     // Give time for any background operations to settle
-    sleep(Duration::from_millis(1000)).await;
+    sleep(Duration::from_millis(2000)).await; // Extended timeout
     
     // Verify source is in a stable state
-    let final_source = state.db.get_source(user_id, source.id).await
+    let mut final_source = state.db.get_source(user_id, source.id).await
         .expect("Failed to get source")
         .expect("Source should exist");
     
+    // If source is still syncing, try force reset as failsafe
+    if matches!(final_source.status, SourceStatus::Syncing) {
+        println!("Source still syncing after 2s, attempting force reset...");
+        let scheduler = SourceScheduler::new(state.clone());
+        if let Err(e) = scheduler.force_reset_source(source.id).await {
+            println!("Force reset failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source = state.db.get_source(user_id, source.id).await
+                .expect("Failed to get source")
+                .expect("Source should exist");
+            println!("Source status after force reset: {:?}", final_source.status);
+        }
+    }
+    
     // Source should not be stuck in an inconsistent state
     assert!(matches!(final_source.status, SourceStatus::Idle | SourceStatus::Error),
            "Source should be in a stable state, got: {:?}", final_source.status);

tests/integration_webdav_critical_fixes_tests.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use std::sync::Arc;
 use std::time::Instant;
 use uuid::Uuid;
@@ -15,175 +16,201 @@ use readur::{
 #[tokio::test]
 async fn test_race_condition_fix_atomic_updates() {
     let test_context = TestContext::new().await;
-    let db = Arc::new(test_context.state.db.clone());
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "race_testuser".to_string(),
-        email: "race@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create initial directories
-    let initial_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir1".to_string(),
-            directory_etag: "initial_etag1".to_string(),
-            file_count: 5,
-            total_size_bytes: 1024,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/dir2".to_string(),
-            directory_etag: "initial_etag2".to_string(),
-            file_count: 10,
-            total_size_bytes: 2048,
-        },
-    ];
-    
-    let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
-    
-    // Simulate race condition: multiple tasks trying to update directories simultaneously
-    let mut handles = vec![];
-    
-    for i in 0..5 {
-        let db_clone = Arc::clone(&db);
-        let handle = tokio::spawn(async move {
-            let updated_directories = vec![
-                CreateWebDAVDirectory {
-                    user_id,
-                    directory_path: "/test/dir1".to_string(),
-                    directory_etag: format!("race_etag1_{}", i),
-                    file_count: 5 + i as i64,
-                    total_size_bytes: 1024 + (i * 100) as i64,
-                },
-                CreateWebDAVDirectory {
-                    user_id,
-                    directory_path: "/test/dir2".to_string(),
-                    directory_etag: format!("race_etag2_{}", i),
-                    file_count: 10 + i as i64,
-                    total_size_bytes: 2048 + (i * 200) as i64,
-                },
-                CreateWebDAVDirectory {
-                    user_id,
-                    directory_path: format!("/test/new_dir_{}", i),
-                    directory_etag: format!("new_etag_{}", i),
-                    file_count: i as i64,
-                    total_size_bytes: (i * 512) as i64,
-                },
-            ];
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = Arc::new(test_context.state.db.clone());
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "race_testuser".to_string(),
+            email: "race@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create initial directories
+        let initial_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir1".to_string(),
+                directory_etag: "initial_etag1".to_string(),
+                file_count: 5,
+                total_size_bytes: 1024,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/dir2".to_string(),
+                directory_etag: "initial_etag2".to_string(),
+                file_count: 10,
+                total_size_bytes: 2048,
+            },
+        ];
+
+        let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
+
+        // Simulate race condition: multiple tasks trying to update directories simultaneously
+        let mut handles = vec![];
+
+        for i in 0..5 {
+            let db_clone = Arc::clone(&db);
+            let handle = tokio::spawn(async move {
+                let updated_directories = vec![
+                    CreateWebDAVDirectory {
+                        user_id,
+                        directory_path: "/test/dir1".to_string(),
+                        directory_etag: format!("race_etag1_{}", i),
+                        file_count: 5 + i as i64,
+                        total_size_bytes: 1024 + (i * 100) as i64,
+                    },
+                    CreateWebDAVDirectory {
+                        user_id,
+                        directory_path: "/test/dir2".to_string(),
+                        directory_etag: format!("race_etag2_{}", i),
+                        file_count: 10 + i as i64,
+                        total_size_bytes: 2048 + (i * 200) as i64,
+                    },
+                    CreateWebDAVDirectory {
+                        user_id,
+                        directory_path: format!("/test/new_dir_{}", i),
+                        directory_etag: format!("new_etag_{}", i),
+                        file_count: i as i64,
+                        total_size_bytes: (i * 512) as i64,
+                    },
+                ];
+
+                // Use the atomic sync operation
+                db_clone.sync_webdav_directories(user_id, &updated_directories).await
+            });
+            handles.push(handle);
+        }
+
+        // Wait for all operations to complete
+        let results: Vec<_> = join_all(handles).await;
+
+        // All operations should succeed (transactions ensure atomicity)
+        for result in results {
+            assert!(result.is_ok());
+            let sync_result = result.unwrap();
+            assert!(sync_result.is_ok());
+        }
+
+        // Final state should be consistent
+        let final_directories = db.list_webdav_directories(user_id).await.unwrap();
+
+        // Should have 3 directories (dir1, dir2, and one of the new_dir_X)
+        assert_eq!(final_directories.len(), 3);
+
+        // All ETags should be from one consistent transaction
+        let dir1 = final_directories.iter().find(|d| d.directory_path == "/test/dir1").unwrap();
+        let dir2 = final_directories.iter().find(|d| d.directory_path == "/test/dir2").unwrap();
+
+        // ETags should be from the same transaction (both should end with same number)
+        let etag1_suffix = dir1.directory_etag.chars().last().unwrap();
+        let etag2_suffix = dir2.directory_etag.chars().last().unwrap();
+        assert_eq!(etag1_suffix, etag2_suffix, "ETags should be from same atomic transaction");
             
-            // Use the atomic sync operation
-            db_clone.sync_webdav_directories(user_id, &updated_directories).await
-        });
-        handles.push(handle);
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
-    
-    // Wait for all operations to complete
-    let results: Vec<_> = join_all(handles).await;
-    
-    // All operations should succeed (transactions ensure atomicity)
-    for result in results {
-        assert!(result.is_ok());
-        let sync_result = result.unwrap();
-        assert!(sync_result.is_ok());
-    }
-    
-    // Final state should be consistent
-    let final_directories = db.list_webdav_directories(user_id).await.unwrap();
-    
-    // Should have 3 directories (dir1, dir2, and one of the new_dir_X)
-    assert_eq!(final_directories.len(), 3);
-    
-    // All ETags should be from one consistent transaction
-    let dir1 = final_directories.iter().find(|d| d.directory_path == "/test/dir1").unwrap();
-    let dir2 = final_directories.iter().find(|d| d.directory_path == "/test/dir2").unwrap();
-    
-    // ETags should be from the same transaction (both should end with same number)
-    let etag1_suffix = dir1.directory_etag.chars().last().unwrap();
-    let etag2_suffix = dir2.directory_etag.chars().last().unwrap();
-    assert_eq!(etag1_suffix, etag2_suffix, "ETags should be from same atomic transaction");
-}
 
 /// Test that validates directory deletion detection works correctly
 #[tokio::test]
 async fn test_deletion_detection_fix() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "deletion_testuser".to_string(),
-        email: "deletion@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create initial directories
-    let initial_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents/folder1".to_string(),
-            directory_etag: "etag1".to_string(),
-            file_count: 5,
-            total_size_bytes: 1024,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents/folder2".to_string(),
-            directory_etag: "etag2".to_string(),
-            file_count: 3,
-            total_size_bytes: 512,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents/folder3".to_string(),
-            directory_etag: "etag3".to_string(),
-            file_count: 8,
-            total_size_bytes: 2048,
-        },
-    ];
-    
-    let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
-    
-    // Verify all 3 directories exist
-    let directories_before = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(directories_before.len(), 3);
-    
-    // Simulate sync where folder2 and folder3 are deleted from WebDAV server
-    let current_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents/folder1".to_string(),
-            directory_etag: "etag1_updated".to_string(), // Updated
-            file_count: 6,
-            total_size_bytes: 1200,
-        },
-        // folder2 and folder3 are missing (deleted from server)
-    ];
-    
-    // Use atomic sync which should detect and remove deleted directories
-    let (updated_directories, deleted_count) = db.sync_webdav_directories(user_id, &current_directories).await.unwrap();
-    
-    // Should have 1 updated directory and 2 deletions
-    assert_eq!(updated_directories.len(), 1);
-    assert_eq!(deleted_count, 2);
-    
-    // Verify only folder1 remains with updated ETag
-    let final_directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(final_directories.len(), 1);
-    assert_eq!(final_directories[0].directory_path, "/documents/folder1");
-    assert_eq!(final_directories[0].directory_etag, "etag1_updated");
-    assert_eq!(final_directories[0].file_count, 6);
-}
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "deletion_testuser".to_string(),
+            email: "deletion@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create initial directories
+        let initial_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents/folder1".to_string(),
+                directory_etag: "etag1".to_string(),
+                file_count: 5,
+                total_size_bytes: 1024,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents/folder2".to_string(),
+                directory_etag: "etag2".to_string(),
+                file_count: 3,
+                total_size_bytes: 512,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents/folder3".to_string(),
+                directory_etag: "etag3".to_string(),
+                file_count: 8,
+                total_size_bytes: 2048,
+            },
+        ];
+
+        let _ = db.bulk_create_or_update_webdav_directories(&initial_directories).await.unwrap();
+
+        // Verify all 3 directories exist
+        let directories_before = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(directories_before.len(), 3);
+
+        // Simulate sync where folder2 and folder3 are deleted from WebDAV server
+        let current_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents/folder1".to_string(),
+                directory_etag: "etag1_updated".to_string(), // Updated
+                file_count: 6,
+                total_size_bytes: 1200,
+            },
+            // folder2 and folder3 are missing (deleted from server)
+        ];
+
+        // Use atomic sync which should detect and remove deleted directories
+        let (updated_directories, deleted_count) = db.sync_webdav_directories(user_id, &current_directories).await.unwrap();
+
+        // Should have 1 updated directory and 2 deletions
+        assert_eq!(updated_directories.len(), 1);
+        assert_eq!(deleted_count, 2);
+
+        // Verify only folder1 remains with updated ETag
+        let final_directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(final_directories.len(), 1);
+        assert_eq!(final_directories[0].directory_path, "/documents/folder1");
+        assert_eq!(final_directories[0].directory_etag, "etag1_updated");
+        assert_eq!(final_directories[0].file_count, 6);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
 
 /// Test that validates proper ETag comparison handling
 #[tokio::test]
@@ -224,189 +251,228 @@ async fn test_etag_comparison_fix() {
 #[tokio::test]
 async fn test_bulk_operations_performance() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "perf_testuser".to_string(),
-        email: "perf@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create test data
-    let test_directories: Vec<_> = (0..100).map(|i| CreateWebDAVDirectory {
-        user_id,
-        directory_path: format!("/test/perf/dir{}", i),
-        directory_etag: format!("etag{}", i),
-        file_count: i as i64,
-        total_size_bytes: (i * 1024) as i64,
-    }).collect();
-    
-    // Test individual operations (old way)
-    let start_individual = Instant::now();
-    for directory in &test_directories {
-        let _ = db.create_or_update_webdav_directory(directory).await;
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "perf_testuser".to_string(),
+            email: "perf@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create test data
+        let test_directories: Vec<_> = (0..100).map(|i| CreateWebDAVDirectory {
+            user_id,
+            directory_path: format!("/test/perf/dir{}", i),
+            directory_etag: format!("etag{}", i),
+            file_count: i as i64,
+            total_size_bytes: (i * 1024) as i64,
+        }).collect();
+
+        // Test individual operations (old way)
+        let start_individual = Instant::now();
+        for directory in &test_directories {
+            let _ = db.create_or_update_webdav_directory(directory).await;
+        }
+        let individual_duration = start_individual.elapsed();
+
+        // Clear data
+        let _ = db.clear_webdav_directories(user_id).await;
+
+        // Test bulk operation (new way)
+        let start_bulk = Instant::now();
+        let _ = db.bulk_create_or_update_webdav_directories(&test_directories).await;
+        let bulk_duration = start_bulk.elapsed();
+
+        // Bulk should be faster
+        assert!(bulk_duration < individual_duration, 
+               "Bulk operations should be faster than individual operations. Bulk: {:?}, Individual: {:?}", 
+               bulk_duration, individual_duration);
+
+        // Verify all data was saved correctly
+        let saved_directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(saved_directories.len(), 100);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
     }
-    let individual_duration = start_individual.elapsed();
-    
-    // Clear data
-    let _ = db.clear_webdav_directories(user_id).await;
-    
-    // Test bulk operation (new way)
-    let start_bulk = Instant::now();
-    let _ = db.bulk_create_or_update_webdav_directories(&test_directories).await;
-    let bulk_duration = start_bulk.elapsed();
-    
-    // Bulk should be faster
-    assert!(bulk_duration < individual_duration, 
-           "Bulk operations should be faster than individual operations. Bulk: {:?}, Individual: {:?}", 
-           bulk_duration, individual_duration);
-    
-    // Verify all data was saved correctly
-    let saved_directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(saved_directories.len(), 100);
-}
 
 /// Test transaction rollback behavior
 #[tokio::test]
 async fn test_transaction_rollback_consistency() {
     let test_context = TestContext::new().await;
-    let db = &test_context.state.db;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "rollback_testuser".to_string(),
-        email: "rollback@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Create some initial data
-    let initial_directory = CreateWebDAVDirectory {
-        user_id,
-        directory_path: "/test/initial".to_string(),
-        directory_etag: "initial_etag".to_string(),
-        file_count: 1,
-        total_size_bytes: 100,
-    };
-    
-    let _ = db.create_or_update_webdav_directory(&initial_directory).await.unwrap();
-    
-    // Try to create directories where one has invalid data that should cause rollback
-    let directories_with_failure = vec![
-        CreateWebDAVDirectory {
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let db = &test_context.state.db;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "rollback_testuser".to_string(),
+            email: "rollback@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Create some initial data
+        let initial_directory = CreateWebDAVDirectory {
             user_id,
-            directory_path: "/test/valid1".to_string(),
-            directory_etag: "valid_etag1".to_string(),
-            file_count: 2,
-            total_size_bytes: 200,
-        },
-        CreateWebDAVDirectory {
-            user_id: Uuid::nil(), // This should cause a constraint violation
-            directory_path: "/test/invalid".to_string(),
-            directory_etag: "invalid_etag".to_string(),
-            file_count: 3,
-            total_size_bytes: 300,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/test/valid2".to_string(),
-            directory_etag: "valid_etag2".to_string(),
-            file_count: 4,
-            total_size_bytes: 400,
-        },
-    ];
-    
-    // This should fail and rollback
-    let result = db.bulk_create_or_update_webdav_directories(&directories_with_failure).await;
-    assert!(result.is_err(), "Transaction should fail due to invalid user_id");
-    
-    // Verify that no partial changes were made - only initial directory should exist
-    let final_directories = db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(final_directories.len(), 1);
-    assert_eq!(final_directories[0].directory_path, "/test/initial");
-    assert_eq!(final_directories[0].directory_etag, "initial_etag");
-}
+            directory_path: "/test/initial".to_string(),
+            directory_etag: "initial_etag".to_string(),
+            file_count: 1,
+            total_size_bytes: 100,
+        };
+
+        let _ = db.create_or_update_webdav_directory(&initial_directory).await.unwrap();
+
+        // Try to create directories where one has invalid data that should cause rollback
+        let directories_with_failure = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/valid1".to_string(),
+                directory_etag: "valid_etag1".to_string(),
+                file_count: 2,
+                total_size_bytes: 200,
+            },
+            CreateWebDAVDirectory {
+                user_id: Uuid::nil(), // This should cause a constraint violation
+                directory_path: "/test/invalid".to_string(),
+                directory_etag: "invalid_etag".to_string(),
+                file_count: 3,
+                total_size_bytes: 300,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/test/valid2".to_string(),
+                directory_etag: "valid_etag2".to_string(),
+                file_count: 4,
+                total_size_bytes: 400,
+            },
+        ];
+
+        // This should fail and rollback
+        let result = db.bulk_create_or_update_webdav_directories(&directories_with_failure).await;
+        assert!(result.is_err(), "Transaction should fail due to invalid user_id");
+
+        // Verify that no partial changes were made - only initial directory should exist
+        let final_directories = db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(final_directories.len(), 1);
+        assert_eq!(final_directories[0].directory_path, "/test/initial");
+        assert_eq!(final_directories[0].directory_etag, "initial_etag");
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }
 
 /// Integration test simulating real WebDAV sync scenario
 #[tokio::test]
 async fn test_full_sync_integration() {
     let test_context = TestContext::new().await;
-    let app_state = &test_context.state;
-    
-    // Create a test user first
-    let create_user = CreateUser {
-        username: "sync_testuser".to_string(),
-        email: "sync@example.com".to_string(),
-        password: "password123".to_string(),
-        role: Some(UserRole::User),
-    };
-    let user = app_state.db.create_user(create_user).await
-        .expect("Failed to create test user");
-    let user_id = user.id;
-    
-    // Simulate initial sync with some directories
-    let initial_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents".to_string(),
-            directory_etag: "docs_etag_v1".to_string(),
-            file_count: 10,
-            total_size_bytes: 10240,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/pictures".to_string(),
-            directory_etag: "pics_etag_v1".to_string(),
-            file_count: 5,
-            total_size_bytes: 51200,
-        },
-    ];
-    
-    let (saved_dirs, _) = app_state.db.sync_webdav_directories(user_id, &initial_directories).await.unwrap();
-    assert_eq!(saved_dirs.len(), 2);
-    
-    // Simulate second sync with changes
-    let updated_directories = vec![
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/documents".to_string(),
-            directory_etag: "docs_etag_v2".to_string(), // Changed
-            file_count: 12,
-            total_size_bytes: 12288,
-        },
-        CreateWebDAVDirectory {
-            user_id,
-            directory_path: "/videos".to_string(), // New directory
-            directory_etag: "videos_etag_v1".to_string(),
-            file_count: 3,
-            total_size_bytes: 102400,
-        },
-        // /pictures directory was deleted from server
-    ];
-    
-    let (updated_dirs, deleted_count) = app_state.db.sync_webdav_directories(user_id, &updated_directories).await.unwrap();
-    
-    // Should have 2 directories (updated documents + new videos) and 1 deletion (pictures)
-    assert_eq!(updated_dirs.len(), 2);
-    assert_eq!(deleted_count, 1);
-    
-    // Verify final state
-    let final_dirs = app_state.db.list_webdav_directories(user_id).await.unwrap();
-    assert_eq!(final_dirs.len(), 2);
-    
-    let docs_dir = final_dirs.iter().find(|d| d.directory_path == "/documents").unwrap();
-    assert_eq!(docs_dir.directory_etag, "docs_etag_v2");
-    assert_eq!(docs_dir.file_count, 12);
-    
-    let videos_dir = final_dirs.iter().find(|d| d.directory_path == "/videos").unwrap();
-    assert_eq!(videos_dir.directory_etag, "videos_etag_v1");
-    assert_eq!(videos_dir.file_count, 3);
-}
+        
+        // Ensure cleanup happens even if test fails
+        let result: Result<()> = async {
+        let app_state = &test_context.state;
+
+        // Create a test user first
+        let create_user = CreateUser {
+            username: "sync_testuser".to_string(),
+            email: "sync@example.com".to_string(),
+            password: "password123".to_string(),
+            role: Some(UserRole::User),
+        };
+        let user = app_state.db.create_user(create_user).await
+            .expect("Failed to create test user");
+        let user_id = user.id;
+
+        // Simulate initial sync with some directories
+        let initial_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents".to_string(),
+                directory_etag: "docs_etag_v1".to_string(),
+                file_count: 10,
+                total_size_bytes: 10240,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/pictures".to_string(),
+                directory_etag: "pics_etag_v1".to_string(),
+                file_count: 5,
+                total_size_bytes: 51200,
+            },
+        ];
+
+        let (saved_dirs, _) = app_state.db.sync_webdav_directories(user_id, &initial_directories).await.unwrap();
+        assert_eq!(saved_dirs.len(), 2);
+
+        // Simulate second sync with changes
+        let updated_directories = vec![
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/documents".to_string(),
+                directory_etag: "docs_etag_v2".to_string(), // Changed
+                file_count: 12,
+                total_size_bytes: 12288,
+            },
+            CreateWebDAVDirectory {
+                user_id,
+                directory_path: "/videos".to_string(), // New directory
+                directory_etag: "videos_etag_v1".to_string(),
+                file_count: 3,
+                total_size_bytes: 102400,
+            },
+            // /pictures directory was deleted from server
+        ];
+
+        let (updated_dirs, deleted_count) = app_state.db.sync_webdav_directories(user_id, &updated_directories).await.unwrap();
+
+        // Should have 2 directories (updated documents + new videos) and 1 deletion (pictures)
+        assert_eq!(updated_dirs.len(), 2);
+        assert_eq!(deleted_count, 1);
+
+        // Verify final state
+        let final_dirs = app_state.db.list_webdav_directories(user_id).await.unwrap();
+        assert_eq!(final_dirs.len(), 2);
+
+        let docs_dir = final_dirs.iter().find(|d| d.directory_path == "/documents").unwrap();
+        assert_eq!(docs_dir.directory_etag, "docs_etag_v2");
+        assert_eq!(docs_dir.file_count, 12);
+
+        let videos_dir = final_dirs.iter().find(|d| d.directory_path == "/videos").unwrap();
+        assert_eq!(videos_dir.directory_etag, "videos_etag_v1");
+        assert_eq!(videos_dir.file_count, 3);
+            
+            Ok(())
+        }.await;
+        
+        // Always cleanup database connections and test data
+        if let Err(e) = ctx.cleanup_and_close().await {
+            eprintln!("Warning: Test cleanup failed: {}", e);
+        }
+        
+        result.unwrap();
+    }

tests/integration_webdav_scheduler_concurrency_tests.rs

@@ -166,10 +166,23 @@ async fn test_concurrent_sync_trigger_and_stop() {
     }
     
     // Final source should be in a consistent state (not stuck in "Syncing")
-    sleep(Duration::from_millis(100)).await; // Allow operations to complete
-    let final_source = state.db.get_source(user_id, source.id).await.unwrap().unwrap();
+    sleep(Duration::from_millis(2000)).await; // Allow more time for operations to complete
+    let mut final_source = state.db.get_source(user_id, source.id).await.unwrap().unwrap();
     println!("Final source status after concurrent operations: {:?}", final_source.status);
     
+    // If source is still syncing, try force reset as fallback
+    if matches!(final_source.status, SourceStatus::Syncing) {
+        println!("Source still syncing, attempting force reset...");
+        let scheduler = SourceScheduler::new(state.clone());
+        if let Err(e) = scheduler.force_reset_source(source.id).await {
+            println!("Force reset failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source = state.db.get_source(user_id, source.id).await.unwrap().unwrap();
+            println!("Source status after force reset: {:?}", final_source.status);
+        }
+    }
+    
     // The source should not be permanently stuck in Syncing state
     assert_ne!(final_source.status, SourceStatus::Syncing, 
                "Source should not be stuck in syncing state after concurrent operations");

tests/webdav_production_flow_integration_tests.rs

@@ -348,12 +348,27 @@ async fn test_production_sync_flow_concurrent_sources() {
     // Should have directories from successful syncs
     assert!(final_directories.len() > 0, "Should have discovered some directories");
     
-    // Verify all sources are in consistent states
+    // Verify all sources are in consistent states with force reset failsafe
+    let scheduler_reset = SourceScheduler::new(state.clone());
     for source in sources {
-        let final_source = state.db.get_source(user_id, source.id).await
+        let mut final_source = state.db.get_source(user_id, source.id).await
             .expect("Failed to get source")
             .expect("Source should exist");
         
+        // If source is still syncing, try force reset as failsafe
+        if matches!(final_source.status, SourceStatus::Syncing) {
+            println!("Source {} still syncing, attempting force reset...", source.name);
+            if let Err(e) = scheduler_reset.force_reset_source(source.id).await {
+                println!("Force reset source {} failed: {}", source.name, e);
+            } else {
+                sleep(Duration::from_millis(100)).await;
+                final_source = state.db.get_source(user_id, source.id).await
+                    .expect("Failed to get source")
+                    .expect("Source should exist");
+                println!("Source {} status after force reset: {:?}", source.name, final_source.status);
+            }
+        }
+        
         // Source should not be stuck in syncing state
         assert_ne!(final_source.status, SourceStatus::Syncing,
                   "Source {} should not be stuck in syncing state", source.name);
@@ -457,14 +472,42 @@ async fn test_production_concurrent_user_actions() {
     // Give time for any background operations to settle
     sleep(Duration::from_millis(3000)).await;
     
-    // Verify final state after chaotic user interactions
-    let final_source1 = state.db.get_source(user_id, source1.id).await
+    // Verify final state after chaotic user interactions with force reset failsafe
+    let mut final_source1 = state.db.get_source(user_id, source1.id).await
         .expect("Failed to get source1")
         .expect("Source1 should exist");
-    let final_source2 = state.db.get_source(user_id, source2.id).await
+    let mut final_source2 = state.db.get_source(user_id, source2.id).await
         .expect("Failed to get source2")
         .expect("Source2 should exist");
     
+    // If sources are still syncing, try force reset as failsafe
+    let scheduler_reset = SourceScheduler::new(state.clone());
+    if matches!(final_source1.status, SourceStatus::Syncing) {
+        println!("Source1 still syncing after chaotic user actions, attempting force reset...");
+        if let Err(e) = scheduler_reset.force_reset_source(source1.id).await {
+            println!("Force reset source1 failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source1 = state.db.get_source(user_id, source1.id).await
+                .expect("Failed to get source1")
+                .expect("Source1 should exist");
+            println!("Source1 status after force reset: {:?}", final_source1.status);
+        }
+    }
+    
+    if matches!(final_source2.status, SourceStatus::Syncing) {
+        println!("Source2 still syncing after chaotic user actions, attempting force reset...");
+        if let Err(e) = scheduler_reset.force_reset_source(source2.id).await {
+            println!("Force reset source2 failed: {}", e);
+        } else {
+            sleep(Duration::from_millis(100)).await;
+            final_source2 = state.db.get_source(user_id, source2.id).await
+                .expect("Failed to get source2")
+                .expect("Source2 should exist");
+            println!("Source2 status after force reset: {:?}", final_source2.status);
+        }
+    }
+    
     // Both sources should be in stable states (not stuck in syncing)
     assert!(matches!(final_source1.status, SourceStatus::Idle | SourceStatus::Error),
            "Source1 should be stable: {:?}", final_source1.status);