Function setup_test_server_with_init

tests/common/mod.rs:46–104

Setup a test server with custom initialization

(init: F)

/// Setup a test server with custom initialization
pub async fn setup_test_server_with_init<F, Fut>(init: F) -> TestServer 
where
    F: FnOnce(Arc<pgsqlite::session::DbHandler>) -> Fut + Send + 'static,
    Fut: std::future::Future<Output = Result<(), Box<dyn std::error::Error + Send + Sync>>> + Send,
{
    // Start test server
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();
    
    let test_id = Uuid::new_v4().to_string().replace("-", "");
    let db_path = format!("/tmp/pgsqlite_test_{test_id}.db");
    let db_path_clone = db_path.clone();
    
    let server_handle = tokio::spawn(async move {
        let db_handler = Arc::new(
            pgsqlite::session::DbHandler::new(&db_path_clone).unwrap()
        );
        
        // Run custom initialization
        if let Err(e) = init(db_handler.clone()).await {
            eprintln!("Init error: {e}");
            return;
        }
        
        // Force a comprehensive cache refresh after initialization
        // This ensures that tables created during init are visible to catalog queries
        // In connection-per-session mode, we use execute method instead of direct connection access
        let _ = db_handler.execute("PRAGMA schema_version").await;
        let _ = db_handler.execute("PRAGMA table_list").await;
        
        // Add a small delay to ensure changes propagate
        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
        
        let (stream, addr) = listener.accept().await.unwrap();
        if let Err(e) = pgsqlite::handle_test_connection_with_pool(stream, addr, db_handler).await {
            eprintln!("Connection handling error: {e}");
        }
    });
    
    // Give server time to start
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    
    // Connect with tokio-postgres
    let config = format!("host=localhost port={port} dbname=test user=testuser");
    let (client, connection) = tokio_postgres::connect(&config, NoTls).await.unwrap();
    
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {e}");
        }
    });
    
    TestServer {
        client,
        port,
        server_handle,
        db_path,
    }