diff --git a/server/tests/adresar/put_adresar_test.rs b/server/tests/adresar/put_adresar_test.rs
index fa0042d..a974e6e 100644
--- a/server/tests/adresar/put_adresar_test.rs
+++ b/server/tests/adresar/put_adresar_test.rs
@@ -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();