changing the structure of the unit testing for good

2025-02-24 09:53:50 +01:00
parent 627139d1e2
commit 5df7311e41
5 changed files with 81 additions and 4 deletions
--- a/server/tests/adresar/post_adresar_test.rs
+++ b/server/tests/adresar/post_adresar_test.rs
@@ -0,0 +1,223 @@
+// src/adresar/tests/post_adresar_test.rs
+use super::super::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());
+}
--- a/server/tests/adresar/put_adresar_test.rs
+++ b/server/tests/adresar/put_adresar_test.rs
@@ -0,0 +1,220 @@
+// src/adresar/tests/put_adresar_test.rs
+use super::super::handlers::put_adresar;
+use common::proto::multieko2::adresar::{AdresarResponse, PutAdresarRequest};
+use sqlx::{postgres::PgPoolOptions, PgPool};
+use std::env;
+
+mod test_helpers {
+    use super::*;
+
+    pub async fn setup_test_db() -> (PgPool, i64) {
+        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");
+
+        let record = sqlx::query!(
+            r#"
+            INSERT INTO adresar (
+                firma, kz, drc, ulica, psc, mesto, stat, banka, ucet,
+                skladm, ico, kontakt, telefon, skladu, fax, deleted
+            )
+            VALUES (
+                'Original Company', 'Original KZ', 'Original DRC', 'Original Street',
+                '12345', 'Original City', 'Original Country', 'Original Bank',
+                'Original Account', 'Original SkladM', 'Original ICO',
+                'Original Contact', '+421123456789', 'Original SkladU', 'Original Fax',
+                false
+            )
+            RETURNING id
+            "#
+        )
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+        (pool, record.id)
+    }
+
+    pub fn valid_put_request(id: i64) -> PutAdresarRequest {
+        PutAdresarRequest {
+            id,
+            firma: "Updated Company".into(),
+            kz: "Updated KZ".into(),
+            drc: "Updated DRC".into(),
+            ulica: "Updated Street".into(),
+            psc: "67890".into(),
+            mesto: "Updated City".into(),
+            stat: "Updated Country".into(),
+            banka: "Updated Bank".into(),
+            ucet: "987654321".into(),
+            skladm: "Updated SkladM".into(),
+            ico: "87654321".into(),
+            kontakt: "Jane Doe".into(),
+            telefon: "+421987654321".into(),
+            skladu: "Updated SkladU".into(),
+            fax: "+421987654300".into(),
+        }
+    }
+
+
+    pub async fn assert_response_matches(pool: &PgPool, id: i64, response: &AdresarResponse) {
+        let db_record = sqlx::query!("SELECT * FROM adresar WHERE id = $1", id)
+            .fetch_one(pool)
+            .await
+            .unwrap();
+
+        assert_eq!(db_record.firma, response.firma);
+        assert_eq!(db_record.kz.unwrap_or_default(), response.kz);
+        assert_eq!(db_record.drc.unwrap_or_default(), response.drc);
+        assert_eq!(db_record.ulica.unwrap_or_default(), response.ulica);
+        assert_eq!(db_record.psc.unwrap_or_default(), response.psc);
+        assert_eq!(db_record.mesto.unwrap_or_default(), response.mesto);
+        assert_eq!(db_record.stat.unwrap_or_default(), response.stat);
+        assert_eq!(db_record.banka.unwrap_or_default(), response.banka);
+        assert_eq!(db_record.ucet.unwrap_or_default(), response.ucet);
+        assert_eq!(db_record.skladm.unwrap_or_default(), response.skladm);
+        assert_eq!(db_record.ico.unwrap_or_default(), response.ico);
+        assert_eq!(db_record.kontakt.unwrap_or_default(), response.kontakt);
+        assert_eq!(db_record.telefon.unwrap_or_default(), response.telefon);
+        assert_eq!(db_record.skladu.unwrap_or_default(), response.skladu);
+        assert_eq!(db_record.fax.unwrap_or_default(), response.fax);
+        assert!(!db_record.deleted, "Record should not be deleted");
+    }
+}
+
+#[tokio::test]
+async fn test_update_adresar_success() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let request = test_helpers::valid_put_request(existing_id);
+
+    let response = put_adresar(&pool, request).await.unwrap();
+
+    assert_eq!(response.id, existing_id);
+    test_helpers::assert_response_matches(&pool, existing_id, &response).await;
+}
+
+#[tokio::test]
+async fn test_update_whitespace_fields() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let mut request = test_helpers::valid_put_request(existing_id);
+    request.firma = "  Updated Company  ".into();
+    request.telefon = "  +421987654321  ".into();
+
+    let response = put_adresar(&pool, request).await.unwrap();
+
+    // Verify trimmed values in response
+    assert_eq!(response.firma, "Updated Company");
+    assert_eq!(response.telefon, "+421987654321");
+
+    // Verify raw values in database
+    let db_record = sqlx::query!("SELECT firma, telefon FROM adresar WHERE id = $1", existing_id)
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(db_record.firma, "Updated Company"); // Trimmed
+    assert_eq!(db_record.telefon.unwrap(), "+421987654321"); // Trimmed
+}
+
+#[tokio::test]
+async fn test_update_empty_required_field() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let mut request = test_helpers::valid_put_request(existing_id);
+    request.firma = "".into();
+
+    let result = put_adresar(&pool, request).await;
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument); // Changed from Internal
+}
+
+#[tokio::test]
+async fn test_update_nonexistent_id() {
+    let (pool, _) = test_helpers::setup_test_db().await;
+    let request = test_helpers::valid_put_request(9999);
+
+    let result = put_adresar(&pool, request).await;
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
+}
+
+#[tokio::test]
+async fn test_update_deleted_record() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    sqlx::query!("UPDATE adresar SET deleted = true WHERE id = $1", existing_id)
+        .execute(&pool)
+        .await
+        .unwrap();
+
+    let request = test_helpers::valid_put_request(existing_id);
+    let result = put_adresar(&pool, request).await;
+
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
+}
+
+#[tokio::test]
+async fn test_clear_optional_fields() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let mut request = test_helpers::valid_put_request(existing_id);
+    request.telefon = String::new();
+    request.ulica = String::new();
+
+    let response = put_adresar(&pool, request).await.unwrap();
+
+    // Check response contains empty strings
+    assert!(response.telefon.is_empty());
+    assert!(response.ulica.is_empty());
+
+    // Check database contains NULL
+    let db_record = sqlx::query!("SELECT telefon, ulica FROM adresar WHERE id = $1", existing_id)
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert!(db_record.telefon.is_none());
+    assert!(db_record.ulica.is_none());
+}
+
+#[tokio::test]
+async fn test_max_length_fields() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let mut request = test_helpers::valid_put_request(existing_id);
+    request.firma = "a".repeat(255);
+    request.telefon = "1".repeat(20);
+
+    let _response = put_adresar(&pool, request).await.unwrap();
+
+    let db_record = sqlx::query!("SELECT firma, telefon FROM adresar WHERE id = $1", existing_id)
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(db_record.firma.len(), 255);
+    assert_eq!(db_record.telefon.unwrap().len(), 20);
+}
+
+#[tokio::test]
+async fn test_special_characters() {
+    let (pool, existing_id) = test_helpers::setup_test_db().await;
+    let mut request = test_helpers::valid_put_request(existing_id);
+    request.ulica = "Náměstí 28. října".into();
+    request.telefon = "+420 123-456.789".into();
+
+    let _response = put_adresar(&pool, request).await.unwrap();
+
+    let db_record = sqlx::query!("SELECT ulica, telefon FROM adresar WHERE id = $1", existing_id)
+        .fetch_one(&pool)
+        .await
+        .unwrap();
+
+    assert_eq!(db_record.ulica.unwrap(), "Náměstí 28. října");
+    assert_eq!(db_record.telefon.unwrap(), "+420 123-456.789");
+}