tests are robusts running in parallel

server/tests/common/mod.rs

@@ -1,56 +1,75 @@
 // tests/common/mod.rs
-use dotenvy;
-use sqlx::{postgres::PgPoolOptions, PgPool};
+
+use dotenvy::dotenv;
+// --- CHANGE 1: Add Alphanumeric to the use statement ---
+use rand::distr::Alphanumeric;
+use rand::Rng;
+use sqlx::{postgres::PgPoolOptions, Connection, Executor, PgConnection, PgPool};
 use std::env;
-use std::path::Path;
 
-pub async fn setup_test_db() -> PgPool {
-    // Get path to server directory
-    let manifest_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR must be set");
-    let env_path = Path::new(&manifest_dir).join(".env_test");
+// (The get_database_url and get_root_connection functions remain the same)
+fn get_database_url() -> String {
+    dotenv().ok();
+    env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set")
+}
+async fn get_root_connection() -> PgConnection {
+    PgConnection::connect(&get_database_url())
+        .await
+        .expect("Failed to create root connection to test database")
+}
 
-    // Load environment variables
-    dotenvy::from_path(env_path).ok();
 
-    // Create connection pool
-    let database_url = env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set");
+/// The primary test setup function.
+/// Creates a new, unique schema and returns a connection pool that is scoped to that schema.
+/// This is the key to test isolation.
+pub async fn setup_isolated_db() -> PgPool {
+    let mut root_conn = get_root_connection().await;
+
+    let schema_name = format!(
+        "test_{}",
+        rand::thread_rng()
+            // --- CHANGE 2: Pass a reference to Alphanumeric directly ---
+            .sample_iter(&Alphanumeric)
+            .take(12)
+            .map(char::from)
+            .collect::<String>()
+            .to_lowercase()
+    );
+
+    root_conn
+        .execute(format!("CREATE SCHEMA \"{}\"", schema_name).as_str())
+        .await
+        .unwrap_or_else(|_| panic!("Failed to create schema: {}", schema_name));
+
     let pool = PgPoolOptions::new()
         .max_connections(5)
-        .connect(&database_url)
+        .after_connect(move |conn, _meta| {
+            let schema_name = schema_name.clone();
+            Box::pin(async move {
+                conn.execute(format!("SET search_path TO \"{}\"", schema_name).as_str())
+                    .await?;
+                Ok(())
+            })
+        })
+        .connect(&get_database_url())
         .await
-        .expect("Failed to create pool");
+        .expect("Failed to create isolated pool");
 
-    // Run migrations
     sqlx::migrate!()
         .run(&pool)
         .await
-        .expect("Migrations failed");
+        .expect("Migrations failed in isolated schema");
 
-    // Insert default profile if it doesn't exist
-    let profile = sqlx::query!(
+    sqlx::query!(
         r#"
         INSERT INTO profiles (name)
         VALUES ('default')
         ON CONFLICT (name) DO NOTHING
-        RETURNING id
         "#
     )
-    .fetch_optional(&pool)
+    .execute(&pool)
     .await
-    .expect("Failed to insert test profile");
-
-    let profile_id = if let Some(profile) = profile {
-        profile.id
-    } else {
-        // If the profile already exists, fetch its ID
-        sqlx::query!(
-            "SELECT id FROM profiles WHERE name = 'default'"
-        )
-        .fetch_one(&pool)
-        .await
-        .expect("Failed to fetch default profile ID")
-        .id
-    };
+    .expect("Failed to insert test profile in isolated schema");
 
     pool
 }