filipriec/komp_ac
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

working perfectly well

Browse Source
This commit is contained in:
filipriec
2025-02-24 14:38:33 +01:00
parent ea12e20f87
commit e8a3fdd673
3 changed files with 50 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
server/tests/adresar/post_adresar_test.rs
View File

@@ -1,28 +1,12 @@
// src/adresar/tests/post_adresar_test.rs // tests/adresar/post_adresar_test.rs
use server::adresar::handlers::post_adresar; use server::adresar::handlers::post_adresar;
use common::proto::multieko2::adresar::PostAdresarRequest; use common::proto::multieko2::adresar::PostAdresarRequest;
use sqlx::{postgres::PgPoolOptions, PgPool}; use crate::common::setup_test_db;
use std::env; use sqlx::PgPool;
// Helper functions // Helper functions
mod test_helpers { mod test_helpers {
use super::*; 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 { pub fn valid_request() -> PostAdresarRequest {
PostAdresarRequest { PostAdresarRequest {
@@ -61,7 +45,7 @@ mod test_helpers {
assert_eq!(db_record.firma, response.firma); assert_eq!(db_record.firma, response.firma);
assert_eq!(db_record.telefon, Some(response.telefon.clone())); assert_eq!(db_record.telefon, Some(response.telefon.clone()));
// Add assertions for other fields... // Add assertions for other fields...
// Verify default values // Verify default values
assert!(!db_record.deleted); assert!(!db_record.deleted);
assert!(db_record.created_at.is_some()); assert!(db_record.created_at.is_some());
@@ -70,7 +54,7 @@ mod test_helpers {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_success() { async fn test_create_adresar_success() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let request = test_helpers::valid_request(); let request = test_helpers::valid_request();
let response = post_adresar(&pool, request).await.unwrap(); let response = post_adresar(&pool, request).await.unwrap();
@@ -78,20 +62,20 @@ async fn test_create_adresar_success() {
// Basic response validation // Basic response validation
assert!(response.id > 0, "Should return positive ID"); assert!(response.id > 0, "Should return positive ID");
assert_eq!(response.firma, "Test Company", "Firma should match"); assert_eq!(response.firma, "Test Company", "Firma should match");
// Verify all fields against request // Verify all fields against request
let request = test_helpers::valid_request(); let request = test_helpers::valid_request();
assert_eq!(response.kz, request.kz); assert_eq!(response.kz, request.kz);
assert_eq!(response.drc, request.drc); assert_eq!(response.drc, request.drc);
// Continue for all fields... // Continue for all fields...
// Comprehensive database check // Comprehensive database check
test_helpers::assert_response_matches(&pool, &response).await; test_helpers::assert_response_matches(&pool, &response).await;
} }
#[tokio::test] #[tokio::test]
async fn test_create_adresar_whitespace_trimming() { async fn test_create_adresar_whitespace_trimming() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.firma = " Test Company ".into(); request.firma = " Test Company ".into();
@@ -107,7 +91,7 @@ async fn test_create_adresar_whitespace_trimming() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_empty_optional_fields() { async fn test_create_adresar_empty_optional_fields() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.telefon = " ".into(); // Only whitespace request.telefon = " ".into(); // Only whitespace
@@ -126,7 +110,7 @@ async fn test_create_adresar_empty_optional_fields() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_invalid_firma() { async fn test_create_adresar_invalid_firma() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.firma = " ".into(); // Only whitespace request.firma = " ".into(); // Only whitespace
@@ -138,14 +122,14 @@ async fn test_create_adresar_invalid_firma() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_minimal_valid_request() { async fn test_create_adresar_minimal_valid_request() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let request = test_helpers::minimal_request(); let request = test_helpers::minimal_request();
let response = post_adresar(&pool, request).await.unwrap(); let response = post_adresar(&pool, request).await.unwrap();
assert!(response.id > 0); assert!(response.id > 0);
assert_eq!(response.firma, "Required Only"); assert_eq!(response.firma, "Required Only");
// Verify optional fields are empty // Verify optional fields are empty
assert!(response.kz.is_empty()); assert!(response.kz.is_empty());
assert!(response.drc.is_empty()); assert!(response.drc.is_empty());
@@ -154,7 +138,7 @@ async fn test_create_adresar_minimal_valid_request() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_empty_firma() { async fn test_create_adresar_empty_firma() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::minimal_request(); let mut request = test_helpers::minimal_request();
request.firma = "".into(); request.firma = "".into();
@@ -166,7 +150,7 @@ async fn test_create_adresar_empty_firma() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_database_error() { async fn test_create_adresar_database_error() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
pool.close().await; pool.close().await;
let result = post_adresar(&pool, test_helpers::minimal_request()).await; let result = post_adresar(&pool, test_helpers::minimal_request()).await;
@@ -177,47 +161,47 @@ async fn test_create_adresar_database_error() {
#[tokio::test] #[tokio::test]
async fn test_create_adresar_field_length_limits() { async fn test_create_adresar_field_length_limits() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.firma = "a".repeat(255); request.firma = "a".repeat(255);
request.telefon = "1".repeat(20); // Example length based on DB schema request.telefon = "1".repeat(20); // Example length based on DB schema
let response = post_adresar(&pool, request).await.unwrap(); let response = post_adresar(&pool, request).await.unwrap();
assert_eq!(response.firma.len(), 255); assert_eq!(response.firma.len(), 255);
assert_eq!(response.telefon.len(), 20); assert_eq!(response.telefon.len(), 20);
} }
#[tokio::test] #[tokio::test]
async fn test_create_adresar_special_characters() { async fn test_create_adresar_special_characters() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.telefon = "+420 123-456.789".into(); request.telefon = "+420 123-456.789".into();
request.ulica = "Náměstí 28. října".into(); request.ulica = "Náměstí 28. října".into();
let response = post_adresar(&pool, request.clone()).await.unwrap(); let response = post_adresar(&pool, request.clone()).await.unwrap();
assert_eq!(response.telefon, request.telefon); assert_eq!(response.telefon, request.telefon);
assert_eq!(response.ulica, request.ulica); assert_eq!(response.ulica, request.ulica);
} }
#[tokio::test] #[tokio::test]
async fn test_create_adresar_optional_fields_null_vs_empty() { async fn test_create_adresar_optional_fields_null_vs_empty() {
let pool = test_helpers::setup_test_db().await; let pool = setup_test_db().await;
// Test explicit null (using default values) // Test explicit null (using default values)
let mut request = test_helpers::valid_request(); let mut request = test_helpers::valid_request();
request.telefon = String::new(); request.telefon = String::new();
let response = post_adresar(&pool, request).await.unwrap(); let response = post_adresar(&pool, request).await.unwrap();
// Verify empty string is stored as NULL in database // Verify empty string is stored as NULL in database
let record = sqlx::query!("SELECT telefon FROM adresar WHERE id = $1", response.id) let record = sqlx::query!("SELECT telefon FROM adresar WHERE id = $1", response.id)
.fetch_one(&pool) .fetch_one(&pool)
.await .await
.unwrap(); .unwrap();
assert!(record.telefon.is_none()); assert!(record.telefon.is_none());
} }

91
server/tests/common/mod.rs
View File

@@ -1,77 +1,30 @@
// tests/common/mod.rs // tests/common/mod.rs
use dotenvy;
use sqlx::{postgres::PgPoolOptions, PgPool}; use sqlx::{postgres::PgPoolOptions, PgPool};
use std::env; use std::env;
use tokio::sync::OnceCell; use std::path::Path;
static DB_POOL: OnceCell<PgPool> = OnceCell::const_new(); 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");
pub async fn get_db_pool() -> PgPool { // Load environment variables
DB_POOL.get_or_init(|| async { dotenvy::from_path(env_path).ok();
dotenvy::from_filename(".env_test").ok();
let pool = PgPoolOptions::new()
.max_connections(5)
.connect(&env::var("TEST_DATABASE_URL").unwrap())
.await
.unwrap();
// Run migrations // Create connection pool
sqlx::migrate!() let database_url = env::var("TEST_DATABASE_URL").expect("TEST_DATABASE_URL must be set");
.run(&pool) let pool = PgPoolOptions::new()
.await .max_connections(5)
.expect("Migrations failed"); .connect(&database_url)
pool
}).await.clone()
}
pub async fn cleanup_db(pool: &PgPool) {
sqlx::query!("TRUNCATE TABLE adresar, uctovnictvo RESTART IDENTITY CASCADE")
.execute(pool)
.await .await
.expect("Failed to cleanup test database"); .expect("Failed to create pool");
}
// Run migrations
// Test helpers sqlx::migrate!()
pub mod adresar_helpers { .run(&pool)
use common::proto::multieko2::adresar::{PostAdresarRequest, AdresarResponse}; .await
use sqlx::PgPool; .expect("Migrations failed");
pub fn valid_request() -> PostAdresarRequest { pool
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: &AdresarResponse) {
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()));
assert!(!db_record.deleted);
assert!(db_record.created_at.is_some());
}
} }

1
server/tests/mod.rs
View File

@@ -1,2 +1,3 @@
// tests/mod.rs
pub mod adresar; pub mod adresar;
pub mod common; pub mod common;