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