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

put working also in rstest module

Browse Source
This commit is contained in:
filipriec
2025-02-24 16:49:09 +01:00
parent 040794d59d
commit 70cb2be4fa
1 changed files with 162 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
server/tests/adresar/put_adresar_test.rs
View File

@@ -1,110 +1,121 @@
// src/adresar/tests/put_adresar_test.rs
// tests/adresar/put_adresar_test.rs
use rstest::{fixture, rstest};
use server::adresar::handlers::put_adresar;
use common::proto::multieko2::adresar::{AdresarResponse, PutAdresarRequest};
use sqlx::{postgres::PgPoolOptions, PgPool};
use std::env;
use common::proto::multieko2::adresar::PutAdresarRequest;
use crate::common::setup_test_db;
use sqlx::PgPool;
use tonic;
mod test_helpers {
use super::*;
// Fixtures
#[fixture]
async fn pool() -> PgPool {
setup_test_db().await
}
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();
#[fixture]
async fn closed_pool(#[future] pool: PgPool) -> PgPool {
let pool = pool.await;
pool.close().await;
pool
}
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
"#
#[fixture]
async fn existing_record(#[future] pool: PgPool) -> (PgPool, i64) {
let pool = pool.await;
// Create a test record in the database
let record = sqlx::query!(
r#"
INSERT INTO adresar (
firma, kz, drc, ulica, psc, mesto, stat, banka, ucet,
skladm, ico, kontakt, telefon, skladu, fax, deleted
)
.fetch_one(&pool)
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)
}
#[fixture]
fn valid_request_template() -> PutAdresarRequest {
PutAdresarRequest {
id: 0, // This will be replaced in each test
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(),
}
}
// Helper to check database state
async fn assert_response_matches(pool: &PgPool, id: i64, response: &common::proto::multieko2::adresar::AdresarResponse) {
let db_record = sqlx::query!("SELECT * FROM adresar WHERE id = $1", 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");
}
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");
}
// Tests
#[rstest]
#[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);
async fn test_update_adresar_success(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = 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;
assert_eq!(response.id, id);
assert_response_matches(&pool, id, &response).await;
}
#[rstest]
#[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);
async fn test_update_whitespace_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = id;
request.firma = " Updated Company ".into();
request.telefon = " +421987654321 ".into();
@@ -115,7 +126,7 @@ async fn test_update_whitespace_fields() {
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)
let db_record = sqlx::query!("SELECT firma, telefon FROM adresar WHERE id = $1", id)
.fetch_one(&pool)
.await
.unwrap();
@@ -124,46 +135,75 @@ async fn test_update_whitespace_fields() {
assert_eq!(db_record.telefon.unwrap(), "+421987654321"); // Trimmed
}
#[rstest]
#[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);
async fn test_update_empty_required_field(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = 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
assert_eq!(result.unwrap_err().code(), tonic::Code::InvalidArgument);
}
#[rstest]
#[tokio::test]
async fn test_update_nonexistent_id() {
let (pool, _) = test_helpers::setup_test_db().await;
let request = test_helpers::valid_put_request(9999);
async fn test_update_nonexistent_id(#[future] pool: PgPool) {
let pool = pool.await;
let request = PutAdresarRequest {
id: 9999, // Non-existent 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(),
};
let result = put_adresar(&pool, request).await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}
#[rstest]
#[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)
async fn test_update_deleted_record(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
// Mark the record as deleted
sqlx::query!("UPDATE adresar SET deleted = true WHERE id = $1", id)
.execute(&pool)
.await
.unwrap();
let request = test_helpers::valid_put_request(existing_id);
let result = put_adresar(&pool, request).await;
let mut request = valid_request_template;
request.id = id;
let result = put_adresar(&pool, request).await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code(), tonic::Code::Internal);
}
#[rstest]
#[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);
async fn test_clear_optional_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = id;
request.telefon = String::new();
request.ulica = String::new();
@@ -174,7 +214,7 @@ async fn test_clear_optional_fields() {
assert!(response.ulica.is_empty());
// Check database contains NULL
let db_record = sqlx::query!("SELECT telefon, ulica FROM adresar WHERE id = $1", existing_id)
let db_record = sqlx::query!("SELECT telefon, ulica FROM adresar WHERE id = $1", id)
.fetch_one(&pool)
.await
.unwrap();
@@ -183,16 +223,19 @@ async fn test_clear_optional_fields() {
assert!(db_record.ulica.is_none());
}
#[rstest]
#[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);
async fn test_max_length_fields(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = 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)
let db_record = sqlx::query!("SELECT firma, telefon FROM adresar WHERE id = $1", id)
.fetch_one(&pool)
.await
.unwrap();
@@ -201,16 +244,19 @@ async fn test_max_length_fields() {
assert_eq!(db_record.telefon.unwrap().len(), 20);
}
#[rstest]
#[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);
async fn test_special_characters(#[future] existing_record: (PgPool, i64), valid_request_template: PutAdresarRequest) {
let (pool, id) = existing_record.await;
let mut request = valid_request_template;
request.id = 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)
let db_record = sqlx::query!("SELECT ulica, telefon FROM adresar WHERE id = $1", id)
.fetch_one(&pool)
.await
.unwrap();