267 lines
8.6 KiB
Rust
267 lines
8.6 KiB
Rust
// tests/adresar/put_adresar_test.rs
|
|
use rstest::{fixture, rstest};
|
|
use server::adresar::handlers::put_adresar;
|
|
use common::proto::multieko2::adresar::PutAdresarRequest;
|
|
use crate::common::setup_test_db;
|
|
use sqlx::PgPool;
|
|
use tonic;
|
|
|
|
// Fixtures
|
|
#[fixture]
|
|
async fn pool() -> PgPool {
|
|
setup_test_db().await
|
|
}
|
|
|
|
#[fixture]
|
|
async fn closed_pool(#[future] pool: PgPool) -> PgPool {
|
|
let pool = pool.await;
|
|
pool.close().await;
|
|
pool
|
|
}
|
|
|
|
#[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
|
|
)
|
|
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();
|
|
|
|
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(#[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, id);
|
|
assert_response_matches(&pool, id, &response).await;
|
|
}
|
|
|
|
#[rstest]
|
|
#[tokio::test]
|
|
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();
|
|
|
|
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", id)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(db_record.firma, "Updated Company"); // Trimmed
|
|
assert_eq!(db_record.telefon.unwrap(), "+421987654321"); // Trimmed
|
|
}
|
|
|
|
#[rstest]
|
|
#[tokio::test]
|
|
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);
|
|
}
|
|
|
|
#[rstest]
|
|
#[tokio::test]
|
|
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(#[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 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(#[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();
|
|
|
|
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", id)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(db_record.telefon.is_none());
|
|
assert!(db_record.ulica.is_none());
|
|
}
|
|
|
|
#[rstest]
|
|
#[tokio::test]
|
|
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", id)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(db_record.firma.len(), 255);
|
|
assert_eq!(db_record.telefon.unwrap().len(), 20);
|
|
}
|
|
|
|
#[rstest]
|
|
#[tokio::test]
|
|
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", 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");
|
|
}
|