From 498abad1c060935ce311ac3ea70a8bc6c29c839b Mon Sep 17 00:00:00 2001
From: Ramat <ramatshuaibu@gmail.com>
Date: Sat, 7 Mar 2026 17:18:05 +0100
Subject: [PATCH 1/3] Create booking_lifecycle-test.rs

---
 .../booking_lifecycle-test.rs                 | 366 ++++++++++++++++++
 1 file changed, 366 insertions(+)
 create mode 100644 contracts/workspace_booking/booking_lifecycle-test.rs

diff --git a/contracts/workspace_booking/booking_lifecycle-test.rs b/contracts/workspace_booking/booking_lifecycle-test.rs
new file mode 100644
index 0000000..b0c5305
--- /dev/null
+++ b/contracts/workspace_booking/booking_lifecycle-test.rs
@@ -0,0 +1,366 @@
+#![cfg(test)]
+
+use super::*;
+use soroban_sdk::{
+    testutils::{Address as _, Ledger},
+    token::{Client as TokenClient, StellarAssetClient},
+    Address, Env, String,
+};
+
+fn setup_contract(env: &Env) -> Address {
+    env.register(WorkspaceBookingContract, ())
+}
+
+
+
+fn setup_token(env: &Env, admin: &Address, recipient: &Address, amount: i128) -> Address {
+    let token_address = env.register_stellar_asset_contract_v2(admin.clone()).address();
+    StellarAssetClient::new(env, &token_address)
+        .mock_all_auths()
+        .mint(recipient, &amount);
+    token_address
+}
+
+
+fn advance_time(env: &Env, seconds: u64) {
+    env.ledger().with_mut(|l| l.timestamp += seconds);
+}
+
+
+
+#[test]
+fn test_initialize_success() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    assert_eq!(client.admin(), admin);
+    assert_eq!(client.payment_token(), token);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #3)")]
+fn test_initialize_twice_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+    client.initialize(&admin, &token); 
+}
+
+#[test]
+fn test_register_workspace_success() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let ws = client.get_workspace(&String::from_str(&env, "ws-001"));
+    assert_eq!(ws.name, String::from_str(&env, "Hot Desk A"));
+    assert_eq!(ws.workspace_type, WorkspaceType::HotDesk);
+    assert_eq!(ws.capacity, 1u32);
+    assert_eq!(ws.hourly_rate, 500i128);
+    assert!(ws.is_available);
+
+    let all = client.get_all_workspaces();
+    assert_eq!(all.len(), 1u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #5)")]
+fn test_register_workspace_duplicate_id_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+    
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk B"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #2)")]
+fn test_register_workspace_non_admin_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let non_admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+    
+    client.register_workspace(
+        &non_admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+}
+
+#[test]
+fn test_book_workspace_success() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Meeting Room Alpha"),
+        &WorkspaceType::MeetingRoom,
+        &10u32,
+        &1_000i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 7_200; 
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.workspace_id, String::from_str(&env, "ws-001"));
+    assert_eq!(booking.member, member);
+    assert_eq!(booking.status, BookingStatus::Active);
+    assert_eq!(booking.amount_paid, 2_000i128);
+
+    let balance = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance, 10_000 - 2_000);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #7)")]
+fn test_book_workspace_conflict_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 50_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-002"),
+        &String::from_str(&env, "ws-001"),
+        &(start + 1_800),
+        &(end + 1_800),
+    );
+}
+
+#[test]
+fn test_cancel_booking_refunds_member() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Private Office"),
+        &WorkspaceType::PrivateOffice,
+        &4u32,
+        &2_000i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600; 
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    let balance_after_booking = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance_after_booking, 8_000i128);
+
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+
+    let balance_after_cancel = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance_after_cancel, 10_000i128); 
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.status, BookingStatus::Cancelled);
+}
+
+#[test]
+fn test_complete_booking_by_admin() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Dedicated Desk"),
+        &WorkspaceType::DedicatedDesk,
+        &1u32,
+        &300i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    
+    advance_time(&env, 4_000);
+
+    client.complete_booking(&admin, &String::from_str(&env, "booking-001"));
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.status, BookingStatus::Completed);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")]
+fn test_cancel_already_cancelled_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+    
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+}

From 24ffafe131ff34d3d58edd11fccee9037a31ab53 Mon Sep 17 00:00:00 2001
From: Ramat <ramatshuaibu@gmail.com>
Date: Sun, 8 Mar 2026 06:05:13 +0100
Subject: [PATCH 2/3] Create test.rs

---
 contracts/workspace_booking/src/test.rs | 363 ++++++++++++++++++++++++
 1 file changed, 363 insertions(+)
 create mode 100644 contracts/workspace_booking/src/test.rs

diff --git a/contracts/workspace_booking/src/test.rs b/contracts/workspace_booking/src/test.rs
new file mode 100644
index 0000000..c4dacd7
--- /dev/null
+++ b/contracts/workspace_booking/src/test.rs
@@ -0,0 +1,363 @@
+#![cfg(test)]
+
+use super::*;
+use soroban_sdk::{
+    testutils::{Address as _, Ledger},
+    token::{Client as TokenClient, StellarAssetClient},
+    Address, Env, String,
+};
+
+
+fn setup_contract(env: &Env) -> Address {
+    env.register(WorkspaceBookingContract, ())
+}
+
+fn setup_token(env: &Env, admin: &Address, recipient: &Address, amount: i128) -> Address {
+    let token_address = env.register_stellar_asset_contract_v2(admin.clone()).address();
+    StellarAssetClient::new(env, &token_address)
+        .mock_all_auths()
+        .mint(recipient, &amount);
+    token_address
+}
+
+fn advance_time(env: &Env, seconds: u64) {
+    env.ledger().with_mut(|l| l.timestamp += seconds);
+}
+
+
+#[test]
+fn test_initialize_success() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    assert_eq!(client.admin(), admin);
+    assert_eq!(client.payment_token(), token);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #3)")]
+fn test_initialize_twice_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+    client.initialize(&admin, &token);
+}
+
+#[test]
+fn test_register_workspace_success() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let ws = client.get_workspace(&String::from_str(&env, "ws-001"));
+    assert_eq!(ws.name, String::from_str(&env, "Hot Desk A"));
+    assert_eq!(ws.workspace_type, WorkspaceType::HotDesk);
+    assert_eq!(ws.capacity, 1u32);
+    assert_eq!(ws.hourly_rate, 500i128);
+    assert!(ws.is_available);
+
+    let all = client.get_all_workspaces();
+    assert_eq!(all.len(), 1u32);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #5)")]
+fn test_register_workspace_duplicate_id_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk B"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #2)")]
+fn test_register_workspace_non_admin_fails() {
+    let env = Env::default();
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let non_admin = Address::generate(&env);
+    let token = Address::generate(&env);
+
+    env.mock_all_auths();
+    client.initialize(&admin, &token);
+
+    client.register_workspace(
+        &non_admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+}
+
+#[test]
+fn test_book_workspace_success() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Meeting Room Alpha"),
+        &WorkspaceType::MeetingRoom,
+        &10u32,
+        &1_000i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 7_200;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.workspace_id, String::from_str(&env, "ws-001"));
+    assert_eq!(booking.member, member);
+    assert_eq!(booking.status, BookingStatus::Active);
+    assert_eq!(booking.amount_paid, 2_000i128);
+
+    let balance = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance, 10_000 - 2_000);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #7)")]
+fn test_book_workspace_conflict_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 50_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Desk A"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-002"),
+        &String::from_str(&env, "ws-001"),
+        &(start + 1_800),
+        &(end + 1_800),
+    );
+}
+
+#[test]
+fn test_cancel_booking_refunds_member() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Private Office"),
+        &WorkspaceType::PrivateOffice,
+        &4u32,
+        &2_000i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    let balance_after_booking = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance_after_booking, 8_000i128);
+
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+
+    let balance_after_cancel = TokenClient::new(&env, &token_address).balance(&member);
+    assert_eq!(balance_after_cancel, 10_000i128);
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.status, BookingStatus::Cancelled);
+}
+
+#[test]
+fn test_complete_booking_by_admin() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Dedicated Desk"),
+        &WorkspaceType::DedicatedDesk,
+        &1u32,
+        &300i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+
+    advance_time(&env, 4_000);
+
+    client.complete_booking(&admin, &String::from_str(&env, "booking-001"));
+
+    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
+    assert_eq!(booking.status, BookingStatus::Completed);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")]
+fn test_cancel_already_cancelled_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let contract_id = setup_contract(&env);
+    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
+
+    let admin = Address::generate(&env);
+    let member = Address::generate(&env);
+    let token_address = setup_token(&env, &admin, &member, 10_000i128);
+
+    client.initialize(&admin, &token_address);
+    client.register_workspace(
+        &admin,
+        &String::from_str(&env, "ws-001"),
+        &String::from_str(&env, "Hot Desk"),
+        &WorkspaceType::HotDesk,
+        &1u32,
+        &500i128,
+    );
+
+    let now = env.ledger().timestamp();
+    let start = now + 60;
+    let end = start + 3_600;
+
+    client.book_workspace(
+        &member,
+        &String::from_str(&env, "booking-001"),
+        &String::from_str(&env, "ws-001"),
+        &start,
+        &end,
+    );
+
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+
+    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
+}

From 2ab7651614d4cc78623599244611c453c831a6b5 Mon Sep 17 00:00:00 2001
From: Ramat <ramatshuaibu@gmail.com>
Date: Sun, 8 Mar 2026 06:05:28 +0100
Subject: [PATCH 3/3] Delete
 contracts/workspace_booking/booking_lifecycle-test.rs

---
 .../booking_lifecycle-test.rs                 | 366 ------------------
 1 file changed, 366 deletions(-)
 delete mode 100644 contracts/workspace_booking/booking_lifecycle-test.rs

diff --git a/contracts/workspace_booking/booking_lifecycle-test.rs b/contracts/workspace_booking/booking_lifecycle-test.rs
deleted file mode 100644
index b0c5305..0000000
--- a/contracts/workspace_booking/booking_lifecycle-test.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-#![cfg(test)]
-
-use super::*;
-use soroban_sdk::{
-    testutils::{Address as _, Ledger},
-    token::{Client as TokenClient, StellarAssetClient},
-    Address, Env, String,
-};
-
-fn setup_contract(env: &Env) -> Address {
-    env.register(WorkspaceBookingContract, ())
-}
-
-
-
-fn setup_token(env: &Env, admin: &Address, recipient: &Address, amount: i128) -> Address {
-    let token_address = env.register_stellar_asset_contract_v2(admin.clone()).address();
-    StellarAssetClient::new(env, &token_address)
-        .mock_all_auths()
-        .mint(recipient, &amount);
-    token_address
-}
-
-
-fn advance_time(env: &Env, seconds: u64) {
-    env.ledger().with_mut(|l| l.timestamp += seconds);
-}
-
-
-
-#[test]
-fn test_initialize_success() {
-    let env = Env::default();
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let token = Address::generate(&env);
-
-    env.mock_all_auths();
-    client.initialize(&admin, &token);
-
-    assert_eq!(client.admin(), admin);
-    assert_eq!(client.payment_token(), token);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #3)")]
-fn test_initialize_twice_fails() {
-    let env = Env::default();
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let token = Address::generate(&env);
-
-    env.mock_all_auths();
-    client.initialize(&admin, &token);
-    client.initialize(&admin, &token); 
-}
-
-#[test]
-fn test_register_workspace_success() {
-    let env = Env::default();
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let token = Address::generate(&env);
-
-    env.mock_all_auths();
-    client.initialize(&admin, &token);
-
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Hot Desk A"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-
-    let ws = client.get_workspace(&String::from_str(&env, "ws-001"));
-    assert_eq!(ws.name, String::from_str(&env, "Hot Desk A"));
-    assert_eq!(ws.workspace_type, WorkspaceType::HotDesk);
-    assert_eq!(ws.capacity, 1u32);
-    assert_eq!(ws.hourly_rate, 500i128);
-    assert!(ws.is_available);
-
-    let all = client.get_all_workspaces();
-    assert_eq!(all.len(), 1u32);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #5)")]
-fn test_register_workspace_duplicate_id_fails() {
-    let env = Env::default();
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let token = Address::generate(&env);
-
-    env.mock_all_auths();
-    client.initialize(&admin, &token);
-
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Hot Desk A"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-    
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Hot Desk B"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #2)")]
-fn test_register_workspace_non_admin_fails() {
-    let env = Env::default();
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let non_admin = Address::generate(&env);
-    let token = Address::generate(&env);
-
-    env.mock_all_auths();
-    client.initialize(&admin, &token);
-    
-    client.register_workspace(
-        &non_admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Hot Desk A"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-}
-
-#[test]
-fn test_book_workspace_success() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let member = Address::generate(&env);
-    let token_address = setup_token(&env, &admin, &member, 10_000i128);
-
-    client.initialize(&admin, &token_address);
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Meeting Room Alpha"),
-        &WorkspaceType::MeetingRoom,
-        &10u32,
-        &1_000i128,
-    );
-
-    let now = env.ledger().timestamp();
-    let start = now + 60;
-    let end = start + 7_200; 
-
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-001"),
-        &String::from_str(&env, "ws-001"),
-        &start,
-        &end,
-    );
-
-    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
-    assert_eq!(booking.workspace_id, String::from_str(&env, "ws-001"));
-    assert_eq!(booking.member, member);
-    assert_eq!(booking.status, BookingStatus::Active);
-    assert_eq!(booking.amount_paid, 2_000i128);
-
-    let balance = TokenClient::new(&env, &token_address).balance(&member);
-    assert_eq!(balance, 10_000 - 2_000);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #7)")]
-fn test_book_workspace_conflict_fails() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let member = Address::generate(&env);
-    let token_address = setup_token(&env, &admin, &member, 50_000i128);
-
-    client.initialize(&admin, &token_address);
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Desk A"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-
-    let now = env.ledger().timestamp();
-    let start = now + 60;
-    let end = start + 3_600;
-
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-001"),
-        &String::from_str(&env, "ws-001"),
-        &start,
-        &end,
-    );
-
-    
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-002"),
-        &String::from_str(&env, "ws-001"),
-        &(start + 1_800),
-        &(end + 1_800),
-    );
-}
-
-#[test]
-fn test_cancel_booking_refunds_member() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let member = Address::generate(&env);
-    let token_address = setup_token(&env, &admin, &member, 10_000i128);
-
-    client.initialize(&admin, &token_address);
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Private Office"),
-        &WorkspaceType::PrivateOffice,
-        &4u32,
-        &2_000i128,
-    );
-
-    let now = env.ledger().timestamp();
-    let start = now + 60;
-    let end = start + 3_600; 
-
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-001"),
-        &String::from_str(&env, "ws-001"),
-        &start,
-        &end,
-    );
-
-    let balance_after_booking = TokenClient::new(&env, &token_address).balance(&member);
-    assert_eq!(balance_after_booking, 8_000i128);
-
-    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
-
-    let balance_after_cancel = TokenClient::new(&env, &token_address).balance(&member);
-    assert_eq!(balance_after_cancel, 10_000i128); 
-
-    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
-    assert_eq!(booking.status, BookingStatus::Cancelled);
-}
-
-#[test]
-fn test_complete_booking_by_admin() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let member = Address::generate(&env);
-    let token_address = setup_token(&env, &admin, &member, 10_000i128);
-
-    client.initialize(&admin, &token_address);
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Dedicated Desk"),
-        &WorkspaceType::DedicatedDesk,
-        &1u32,
-        &300i128,
-    );
-
-    let now = env.ledger().timestamp();
-    let start = now + 60;
-    let end = start + 3_600;
-
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-001"),
-        &String::from_str(&env, "ws-001"),
-        &start,
-        &end,
-    );
-
-    
-    advance_time(&env, 4_000);
-
-    client.complete_booking(&admin, &String::from_str(&env, "booking-001"));
-
-    let booking = client.get_booking(&String::from_str(&env, "booking-001"));
-    assert_eq!(booking.status, BookingStatus::Completed);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #10)")]
-fn test_cancel_already_cancelled_fails() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = setup_contract(&env);
-    let client = WorkspaceBookingContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let member = Address::generate(&env);
-    let token_address = setup_token(&env, &admin, &member, 10_000i128);
-
-    client.initialize(&admin, &token_address);
-    client.register_workspace(
-        &admin,
-        &String::from_str(&env, "ws-001"),
-        &String::from_str(&env, "Hot Desk"),
-        &WorkspaceType::HotDesk,
-        &1u32,
-        &500i128,
-    );
-
-    let now = env.ledger().timestamp();
-    let start = now + 60;
-    let end = start + 3_600;
-
-    client.book_workspace(
-        &member,
-        &String::from_str(&env, "booking-001"),
-        &String::from_str(&env, "ws-001"),
-        &start,
-        &end,
-    );
-
-    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
-    
-    client.cancel_booking(&member, &String::from_str(&env, "booking-001"));
-}