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

working

Browse Source
This commit is contained in:
filipriec
2025-02-24 16:32:42 +01:00
parent da89715be3
commit 040794d59d
1 changed files with 66 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,23 +1,20 @@
// tests/adresar/post_adresar_test.rs
// Import the rstest attribute macros.
use rstest::{awt, fixture, rstest};
use rstest::{fixture, rstest};
use server::adresar::handlers::post_adresar;
use common::proto::multieko2::adresar::PostAdresarRequest;
use crate::common::setup_test_db;
use sqlx::PgPool;
use tonic;
// --- Fixtures ---
// Fixtures
#[fixture]
async fn pool() -> PgPool {
setup_test_db().await
}
#[fixture]
async fn closed_pool(pool: PgPool) -> PgPool {
// Close the pool so we can simulate a DB error.
async fn closed_pool(#[future] pool: PgPool) -> PgPool {
let pool = pool.await;
pool.close().await;
pool
}
@@ -51,183 +48,171 @@ fn minimal_request() -> PostAdresarRequest {
}
}
// A helper that checks that the database record matches the response.
async fn assert_response_matches(
pool: &PgPool,
response: &common::proto::multieko2::adresar::AdresarResponse,
) {
// Helper to check database state
async fn assert_response_matches(pool: &PgPool, response: &common::proto::multieko2::adresar::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.as_deref(),
Some(response.telefon.as_str())
);
// More field comparisons can be added here…
assert_eq!(db_record.telefon.as_deref(), Some(response.telefon.as_str()));
// Add assertions for other fields...
assert!(!db_record.deleted);
assert!(db_record.created_at.is_some());
}
// --- Tests ---
// Tests
#[rstest]
#[awt] // awaits all async fixture inputs
#[tokio::test]
async fn test_create_adresar_success(pool: PgPool, valid_request: PostAdresarRequest) {
async fn test_create_adresar_success(#[future] pool: PgPool, valid_request: PostAdresarRequest) {
let pool = pool.await;
let response = post_adresar(&pool, valid_request).await.unwrap();
assert!(response.id > 0, "Should return positive ID");
assert_eq!(response.firma, "Test Company", "Firma should match");
// Comprehensive database check.
assert!(response.id > 0);
assert_eq!(response.firma, "Test Company");
assert_response_matches(&pool, &response).await;
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_whitespace_trimming(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
// Change some fields to include extra whitespace.
valid_request.firma = " Test Company ".into();
valid_request.telefon = " +421123456789 ".into();
valid_request.ulica = " Test Street ".into();
let response = post_adresar(&pool, valid_request).await.unwrap();
let pool = pool.await;
let mut request = 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");
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_empty_optional_fields(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
valid_request.telefon = " ".into();
let pool = pool.await;
let mut request = valid_request;
request.telefon = " ".into();
let response = post_adresar(&pool, valid_request).await.unwrap();
// Check in the database that telefono was stored as NULL.
let response = post_adresar(&pool, request).await.unwrap();
let db_telefon = sqlx::query_scalar!("SELECT telefon FROM adresar WHERE id = $1", response.id)
.fetch_one(&pool)
.await
.unwrap();
assert!(db_telefon.is_none());
// The response still returns an empty string.
assert_eq!(response.telefon, "");
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_invalid_firma(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
valid_request.firma = " ".into();
let pool = pool.await;
let mut request = valid_request;
request.firma = " ".into();
let result = post_adresar(&pool, request).await;
let result = post_adresar(&pool, valid_request).await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_minimal_valid_request(
pool: PgPool,
#[future] pool: PgPool,
minimal_request: PostAdresarRequest,
) {
let pool = pool.await;
let response = post_adresar(&pool, minimal_request).await.unwrap();
assert!(response.id > 0);
assert_eq!(response.firma, "Required Only");
// Verify that all other optional fields appear empty.
assert!(response.kz.is_empty());
assert!(response.drc.is_empty());
// ...and so on.
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_empty_firma(
pool: PgPool,
mut minimal_request: PostAdresarRequest,
#[future] pool: PgPool,
minimal_request: PostAdresarRequest,
) {
minimal_request.firma = "".into();
let pool = pool.await;
let mut request = minimal_request;
request.firma = "".into();
let result = post_adresar(&pool, request).await;
let result = post_adresar(&pool, minimal_request).await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_database_error(
closed_pool: PgPool,
#[future] closed_pool: PgPool,
minimal_request: PostAdresarRequest,
) {
let closed_pool = closed_pool.await;
let result = post_adresar(&closed_pool, minimal_request).await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_field_length_limits(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
valid_request.firma = "a".repeat(255);
valid_request.telefon = "1".repeat(20);
let response = post_adresar(&pool, valid_request).await.unwrap();
let pool = pool.await;
let mut request = valid_request;
request.firma = "a".repeat(255);
request.telefon = "1".repeat(20);
let response = post_adresar(&pool, request).await.unwrap();
assert_eq!(response.firma.len(), 255);
assert_eq!(response.telefon.len(), 20);
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_special_characters(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
valid_request.telefon = "+420 123-456.789".into();
valid_request.ulica = "Náměstí 28. října".into();
let pool = pool.await;
let mut request = valid_request;
request.telefon = "+420 123-456.789".into();
request.ulica = "Náměstí 28. října".into();
let response = post_adresar(&pool, valid_request.clone()).await.unwrap();
assert_eq!(response.telefon, valid_request.telefon);
assert_eq!(response.ulica, valid_request.ulica);
let response = post_adresar(&pool, request.clone()).await.unwrap();
assert_eq!(response.telefon, request.telefon);
assert_eq!(response.ulica, request.ulica);
}
#[rstest]
#[awt]
#[tokio::test]
async fn test_create_adresar_optional_fields_null_vs_empty(
pool: PgPool,
mut valid_request: PostAdresarRequest,
#[future] pool: PgPool,
valid_request: PostAdresarRequest,
) {
valid_request.telefon = String::new();
let pool = pool.await;
let mut request = valid_request;
request.telefon = String::new();
let response = post_adresar(&pool, request).await.unwrap();
let response = post_adresar(&pool, valid_request).await.unwrap();
let db_telefon = sqlx::query_scalar!("SELECT telefon FROM adresar WHERE id = $1", response.id)
.fetch_one(&pool)
.await
@@ -235,4 +220,3 @@ async fn test_create_adresar_optional_fields_null_vs_empty(
assert!(db_telefon.is_none());
}