komp_ac/server/tests/adresar/post_adresar_test.rs

// src/adresar/tests/post_adresar_test.rs
use server::adresar::handlers::post_adresar;
use common::proto::multieko2::adresar::PostAdresarRequest;
use sqlx::{postgres::PgPoolOptions, PgPool};
use std::env;

// Helper functions
mod test_helpers {
    use super::*;
    
    pub async fn setup_test_db() -> PgPool {
        dotenvy::from_filename(".env_test").ok();
        let pool = PgPoolOptions::new()
            .max_connections(5)
            .connect(&env::var("TEST_DATABASE_URL").unwrap())
            .await
            .unwrap();

        sqlx::migrate!()
            .run(&pool)
            .await
            .expect("Migrations failed");

        pool
    }

    pub fn valid_request() -> PostAdresarRequest {
        PostAdresarRequest {
            firma: "Test Company".into(),
            kz: "KZ123".into(),
            drc: "DRC456".into(),
            ulica: "Test Street".into(),
            psc: "12345".into(),
            mesto: "Test City".into(),
            stat: "Test Country".into(),
            banka: "Test Bank".into(),
            ucet: "123456789".into(),
            skladm: "Warehouse M".into(),
            ico: "12345678".into(),
            kontakt: "John Doe".into(),
            telefon: "+421123456789".into(),
            skladu: "Warehouse U".into(),
            fax: "+421123456700".into(),
        }
    }

    pub fn minimal_request() -> PostAdresarRequest {
        PostAdresarRequest {
            firma: "Required Only".into(),
            ..Default::default()
        }
    }

    pub async fn assert_response_matches(pool: &PgPool, response: &common::proto::multieko2::adresar::AdresarResponse) {
        // Verify database state
        let db_record = sqlx::query!("SELECT * FROM adresar WHERE id = $1", response.id)
            .fetch_one(pool)
            .await
            .unwrap();

        assert_eq!(db_record.firma, response.firma);
        assert_eq!(db_record.telefon, Some(response.telefon.clone()));
        // Add assertions for other fields...
        
        // Verify default values
        assert!(!db_record.deleted);
        assert!(db_record.created_at.is_some());
    }
}

#[tokio::test]
async fn test_create_adresar_success() {
    let pool = test_helpers::setup_test_db().await;
    let request = test_helpers::valid_request();

    let response = post_adresar(&pool, request).await.unwrap();

    // Basic response validation
    assert!(response.id > 0, "Should return positive ID");
    assert_eq!(response.firma, "Test Company", "Firma should match");
    
    // Verify all fields against request
    let request = test_helpers::valid_request();
    assert_eq!(response.kz, request.kz);
    assert_eq!(response.drc, request.drc);
    // Continue for all fields...
    
    // Comprehensive database check
    test_helpers::assert_response_matches(&pool, &response).await;
}

#[tokio::test]
async fn test_create_adresar_whitespace_trimming() {
    let pool = test_helpers::setup_test_db().await;

    let mut request = test_helpers::valid_request();
    request.firma = "  Test Company  ".into();
    request.telefon = "  +421123456789  ".into();
    request.ulica = "  Test Street  ".into();

    let response = post_adresar(&pool, request).await.unwrap();

    assert_eq!(response.firma, "Test Company");
    assert_eq!(response.telefon, "+421123456789");
    assert_eq!(response.ulica, "Test Street");
}

#[tokio::test]
async fn test_create_adresar_empty_optional_fields() {
    let pool = test_helpers::setup_test_db().await;

    let mut request = test_helpers::valid_request();
    request.telefon = "   ".into();  // Only whitespace

    let response = post_adresar(&pool, request).await.unwrap();

    // Should be stored as NULL in database
    let record = sqlx::query!("SELECT telefon FROM adresar WHERE id = $1", response.id)
        .fetch_one(&pool)
        .await
        .unwrap();

    assert!(record.telefon.is_none());
    assert_eq!(response.telefon, "");  // Still returns empty string
}

#[tokio::test]
async fn test_create_adresar_invalid_firma() {
    let pool = test_helpers::setup_test_db().await;

    let mut request = test_helpers::valid_request();
    request.firma = "   ".into();  // Only whitespace

    let result = post_adresar(&pool, request).await;
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}

#[tokio::test]
async fn test_create_adresar_minimal_valid_request() {
    let pool = test_helpers::setup_test_db().await;
    let request = test_helpers::minimal_request();

    let response = post_adresar(&pool, request).await.unwrap();

    assert!(response.id > 0);
    assert_eq!(response.firma, "Required Only");
    
    // Verify optional fields are empty
    assert!(response.kz.is_empty());
    assert!(response.drc.is_empty());
    // Continue for all optional fields...
}

#[tokio::test]
async fn test_create_adresar_empty_firma() {
    let pool = test_helpers::setup_test_db().await;
    let mut request = test_helpers::minimal_request();
    request.firma = "".into();

    let result = post_adresar(&pool, request).await;

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

#[tokio::test]
async fn test_create_adresar_database_error() {
    let pool = test_helpers::setup_test_db().await;
    pool.close().await;

    let result = post_adresar(&pool, test_helpers::minimal_request()).await;

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

#[tokio::test]
async fn test_create_adresar_field_length_limits() {
    let pool = test_helpers::setup_test_db().await;
    
    let mut request = test_helpers::valid_request();
    request.firma = "a".repeat(255);
    request.telefon = "1".repeat(20);  // Example length based on DB schema
    
    let response = post_adresar(&pool, request).await.unwrap();
    
    assert_eq!(response.firma.len(), 255);
    assert_eq!(response.telefon.len(), 20);
}

#[tokio::test]
async fn test_create_adresar_special_characters() {
    let pool = test_helpers::setup_test_db().await;
    
    let mut request = test_helpers::valid_request();
    request.telefon = "+420 123-456.789".into();
    request.ulica = "Náměstí 28. října".into();
    
    let response = post_adresar(&pool, request.clone()).await.unwrap();
    
    assert_eq!(response.telefon, request.telefon);
    assert_eq!(response.ulica, request.ulica);
}

#[tokio::test]
async fn test_create_adresar_optional_fields_null_vs_empty() {
    let pool = test_helpers::setup_test_db().await;
    
    // Test explicit null (using default values)
    let mut request = test_helpers::valid_request();
    request.telefon = String::new();
    
    let response = post_adresar(&pool, request).await.unwrap();
    
    // Verify empty string is stored as NULL in database
    let record = sqlx::query!("SELECT telefon FROM adresar WHERE id = $1", response.id)
        .fetch_one(&pool)
        .await
        .unwrap();
        
    assert!(record.telefon.is_none());
}