komp_ac/server/tests/adresar/delete_adresar_test.rs

// tests/adresar/delete_adresar_test.rs
use rstest::{fixture, rstest};
use server::adresar::handlers::delete_adresar;
use common::proto::multieko2::adresar::DeleteAdresarRequest;
use crate::common::setup_test_db;
use sqlx::PgPool;
use tonic;
use std::sync::Arc;
use tokio::sync::Mutex;

// Reuse the mutex from get_adresar_by_position_test or create a new one
lazy_static::lazy_static! {
    static ref TEST_MUTEX: Arc<Mutex<()>> = Arc::new(Mutex::new(()));
}

// Fixtures
#[fixture]
async fn pool() -> PgPool {
    setup_test_db().await
}

#[fixture]
async fn closed_pool(#[future] pool: PgPool) -> PgPool {
    let pool = pool.await;
    pool.close().await;
    pool
}

#[fixture]
async fn existing_record(#[future] pool: PgPool) -> (PgPool, i64, String) {
    let pool = pool.await;
    // Use a unique prefix for test data
    let prefix = format!("DeleteTest_{}", chrono::Utc::now().timestamp_nanos());

    let record = sqlx::query!(
        r#"
        INSERT INTO adresar (firma, deleted)
        VALUES ($1, false)
        RETURNING id
        "#,
        format!("{}_Company", prefix)
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    (pool, record.id, prefix)
}

#[fixture]
async fn existing_deleted_record(#[future] pool: PgPool) -> (PgPool, i64, String) {
    let pool = pool.await;
    // Use a unique prefix for test data
    let prefix = format!("DeletedTest_{}", chrono::Utc::now().timestamp_nanos());

    let record = sqlx::query!(
        r#"
        INSERT INTO adresar (firma, deleted)
        VALUES ($1, true)
        RETURNING id
        "#,
        format!("{}_Deleted", prefix)
    )
    .fetch_one(&pool)
    .await
    .unwrap();

    (pool, record.id, prefix)
}

// Helper to check if the record is deleted
async fn assert_record_deleted(pool: &PgPool, id: i64) {
    let db_record = sqlx::query!("SELECT deleted FROM adresar WHERE id = $1", id)
        .fetch_one(pool)
        .await
        .unwrap();

    assert!(db_record.deleted);
}

// Helper to clean up test records
async fn cleanup_test_records(pool: &PgPool, prefix: &str) {
    if !prefix.is_empty() {
        sqlx::query!(
            "DELETE FROM adresar WHERE firma LIKE $1",
            format!("{}%", prefix)
        )
        .execute(pool)
        .await
        .unwrap();
    }
}

// Tests
#[rstest]
#[tokio::test]
async fn test_delete_adresar_success(
    #[future] existing_record: (PgPool, i64, String),
) {
    // Take a lock to prevent concurrent test execution
    let _guard = TEST_MUTEX.lock().await;

    let (pool, id, prefix) = existing_record.await;
    let request = DeleteAdresarRequest { id };
    let response = delete_adresar(&pool, request).await.unwrap();

    assert!(response.success);
    assert_record_deleted(&pool, id).await;

    // Clean up
    cleanup_test_records(&pool, &prefix).await;
}

#[rstest]
#[tokio::test]
async fn test_delete_adresar_nonexistent_id(
    #[future] pool: PgPool,
) {
    // Take a lock to prevent concurrent test execution
    let _guard = TEST_MUTEX.lock().await;

    let pool = pool.await;
    let request = DeleteAdresarRequest { id: 9999 };
    let response = delete_adresar(&pool, request).await.unwrap();

    // Deleting a non-existent record should return success: false
    assert!(!response.success);
}

#[rstest]
#[tokio::test]
async fn test_delete_adresar_already_deleted(
    #[future] existing_deleted_record: (PgPool, i64, String),
) {
    // Take a lock to prevent concurrent test execution
    let _guard = TEST_MUTEX.lock().await;

    let (pool, id, prefix) = existing_deleted_record.await;
    let request = DeleteAdresarRequest { id };
    let response = delete_adresar(&pool, request).await.unwrap();

    // Deleting an already deleted record should return success: false
    assert!(!response.success);

    // Clean up
    cleanup_test_records(&pool, &prefix).await;
}

#[rstest]
#[tokio::test]
async fn test_delete_adresar_database_error(
    #[future] closed_pool: PgPool,
) {
    // No need for mutex here as we're not modifying the database
    let closed_pool = closed_pool.await;
    let request = DeleteAdresarRequest { id: 1 };
    let result = delete_adresar(&closed_pool, request).await;

    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}