Test coverage: expand invoice-token SEP-41 behavior

contracts/invoice-escrow/src/integration_test.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use super::*;
 use invoice_token::{InvoiceToken, InvoiceTokenClient};
 use soroban_sdk::token::{Client as TokenClient, StellarAssetClient as AssetClient};
@@ -20,11 +18,11 @@ fn test_integration_escrow_lifecycle_happy_path() {
     let payer = Address::generate(&env);
 
     // 2. Register Escrow Contract
-    let escrow_id = env.register_contract(None, InvoiceEscrow);
+    let escrow_id = env.register(InvoiceEscrow, ());
     let escrow_client = InvoiceEscrowClient::new(&env, &escrow_id);
 
     // 3. Register Token Contract
-    let inv_token_id = env.register_contract(None, InvoiceToken);
+    let inv_token_id = env.register(InvoiceToken, ());
     let inv_token_client = InvoiceTokenClient::new(&env, &inv_token_id);
 
     // 4. Register Payment Token (Stellar Asset)
@@ -111,10 +109,10 @@ fn test_integration_refund_lifecycle() {
     let seller = Address::generate(&env);
     let buyer = Address::generate(&env);
 
-    let escrow_id = env.register_contract(None, InvoiceEscrow);
+    let escrow_id = env.register(InvoiceEscrow, ());
     let escrow_client = InvoiceEscrowClient::new(&env, &escrow_id);
 
-    let inv_token_id = env.register_contract(None, InvoiceToken);
+    let inv_token_id = env.register(InvoiceToken, ());
     let inv_token_client = InvoiceTokenClient::new(&env, &inv_token_id);
 
     let payment_token_admin = Address::generate(&env);
@@ -181,10 +179,10 @@ fn test_integration_token_locked_during_active_escrow() {
     let seller = Address::generate(&env);
     let buyer = Address::generate(&env);
 
-    let escrow_id = env.register_contract(None, InvoiceEscrow);
+    let escrow_id = env.register(InvoiceEscrow, ());
     let escrow_client = InvoiceEscrowClient::new(&env, &escrow_id);
 
-    let inv_token_id = env.register_contract(None, InvoiceToken);
+    let inv_token_id = env.register(InvoiceToken, ());
     let inv_token_client = InvoiceTokenClient::new(&env, &inv_token_id);
 
     let payment_token_admin = Address::generate(&env);

contracts/invoice-escrow/src/test.rs

@@ -1,4 +1,3 @@
-#![cfg(test)]
 #![allow(deprecated)]
 
 use super::*;
@@ -397,7 +396,7 @@ fn test_no_settlement_event_on_invalid_state() {
         let (_addr, topics, _data) = event;
         // Check if this is a payment_settled event
         let topic_vec: soroban_sdk::Vec<soroban_sdk::Val> = topics.clone();
-        if topic_vec.len() > 0 {
+        if !topic_vec.is_empty() {
             if let Ok(symbol) = topic_vec.get(0).unwrap().try_into_val(&env) {
                 let sym: Symbol = symbol;
                 // Assert that no payment_settled event exists
@@ -451,7 +450,7 @@ fn test_no_refund_event_on_invalid_state() {
         let (_addr, topics, _data) = event;
         // Check if this is an escrow_refunded event
         let topic_vec: soroban_sdk::Vec<soroban_sdk::Val> = topics.clone();
-        if topic_vec.len() > 0 {
+        if !topic_vec.is_empty() {
             if let Ok(symbol) = topic_vec.get(0).unwrap().try_into_val(&env) {
                 let sym: Symbol = symbol;
                 // Assert that no escrow_refunded event exists

contracts/invoice-token/src/test.rs

@@ -6,7 +6,7 @@ use soroban_sdk::{Address, Env, IntoVal, String as SorobanString, Symbol, TryInt
 
 fn setup_token(env: &Env) -> (InvoiceTokenClient<'_>, Address, Address) {
     let contract_id = env.register(InvoiceToken, ());
-    let client = InvoiceTokenClient::new(&env, &contract_id);
+    let client = InvoiceTokenClient::new(env, &contract_id);
     let admin = Address::generate(env);
     let minter = Address::generate(env);
     let name = SorobanString::from_str(env, "Invoice INV-001");
@@ -245,6 +245,25 @@ fn test_transfer_locked_with_sufficient_balance() {
     assert_eq!(client.balance(&recipient), 0);
 }
 
+#[test]
+fn test_transfer_insufficient_balance_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    // Unlock transfers so we can isolate the balance failure path.
+    client.set_transfer_locked(&admin, &false);
+
+    let sender = Address::generate(&env);
+    let recipient = Address::generate(&env);
+    client.mint(&sender, &50, &minter);
+
+    let result = client.try_transfer(&sender, &recipient, &100);
+    assert_eq!(result, Err(Ok(crate::errors::Error::InsufficientBalance)));
+    assert_eq!(client.balance(&sender), 50);
+    assert_eq!(client.balance(&recipient), 0);
+}
+
 #[test]
 fn test_transfer_event_emission() {
     let env = Env::default();
@@ -334,6 +353,36 @@ fn test_mint_event_emission() {
     assert_eq!(emitted_amount, amount);
 }
 
+#[test]
+fn test_mint_authorization_and_invalid_amount() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    let recipient = Address::generate(&env);
+    let stranger = Address::generate(&env);
+
+    // Admin can mint.
+    client.mint(&recipient, &100, &admin);
+    assert_eq!(client.balance(&recipient), 100);
+    assert_eq!(client.total_supply(), 100);
+
+    // Minter can also mint.
+    client.mint(&recipient, &50, &minter);
+    assert_eq!(client.balance(&recipient), 150);
+    assert_eq!(client.total_supply(), 150);
+
+    // Unauthorized caller is rejected.
+    let unauthorized = client.try_mint(&recipient, &25, &stranger);
+    assert_eq!(unauthorized, Err(Ok(crate::errors::Error::Unauthorized)));
+
+    // Zero amount is rejected even for an authorized caller.
+    let invalid_amount = client.try_mint(&recipient, &0, &minter);
+    assert_eq!(invalid_amount, Err(Ok(crate::errors::Error::InvalidAmount)));
+    assert_eq!(client.balance(&recipient), 150);
+    assert_eq!(client.total_supply(), 150);
+}
+
 #[test]
 fn test_burn_event_emission() {
     let env = Env::default();
@@ -362,6 +411,20 @@ fn test_burn_event_emission() {
     assert_eq!(emitted_amount, burn_amount);
 }
 
+#[test]
+fn test_burn_insufficient_balance_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    client.mint(&admin, &100, &minter);
+
+    let result = client.try_burn(&admin, &200);
+    assert_eq!(result, Err(Ok(crate::errors::Error::InsufficientBalance)));
+    assert_eq!(client.balance(&admin), 100);
+    assert_eq!(client.total_supply(), 100);
+}
+
 #[test]
 fn test_transfer_from_event_emission() {
     let env = Env::default();
@@ -436,6 +499,68 @@ fn test_burn_from_event_emission() {
     assert_eq!(emitted_amount, burn_amount);
 }
 
+#[test]
+fn test_burn_updates_balance_and_total_supply() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    client.mint(&admin, &1000, &minter);
+
+    client.burn(&admin, &300);
+    assert_eq!(client.balance(&admin), 700);
+    assert_eq!(client.total_supply(), 700);
+}
+
+#[test]
+fn test_burn_from_updates_balance_allowance_and_total_supply() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    client.mint(&admin, &1000, &minter);
+
+    let spender = Address::generate(&env);
+    let expiration = env.ledger().sequence() + 100;
+    client.approve(&admin, &spender, &500, &expiration);
+
+    client.burn_from(&spender, &admin, &150);
+    assert_eq!(client.balance(&admin), 850);
+    assert_eq!(client.total_supply(), 850);
+    assert_eq!(client.allowance(&admin, &spender), 350);
+}
+
+#[test]
+fn test_burn_from_allowance_and_balance_checks() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    client.mint(&admin, &100, &minter);
+
+    let spender = Address::generate(&env);
+    let current_ledger = env.ledger().sequence();
+
+    // Insufficient allowance.
+    client.approve(&admin, &spender, &50, &(current_ledger + 100));
+    let allowance_fail = client.try_burn_from(&spender, &admin, &60);
+    assert_eq!(
+        allowance_fail,
+        Err(Ok(crate::errors::Error::InsufficientAllowance))
+    );
+
+    // Sufficient allowance but insufficient balance.
+    client.approve(&admin, &spender, &200, &(current_ledger + 100));
+    let balance_fail = client.try_burn_from(&spender, &admin, &150);
+    assert_eq!(
+        balance_fail,
+        Err(Ok(crate::errors::Error::InsufficientBalance))
+    );
+    assert_eq!(client.balance(&admin), 100);
+    assert_eq!(client.total_supply(), 100);
+    assert_eq!(client.allowance(&admin, &spender), 200);
+}
+
 #[test]
 fn test_no_transfer_event_on_locked_failure() {
     let env = Env::default();
@@ -672,6 +797,27 @@ fn test_transfer_from_expiration_above_current() {
     assert_eq!(client.allowance(&admin, &spender), 300);
 }
 
+#[test]
+fn test_transfer_from_insufficient_allowance_fails() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, admin, minter) = setup_token(&env);
+
+    client.mint(&admin, &1000, &minter);
+    client.set_transfer_locked(&admin, &false);
+
+    let spender = Address::generate(&env);
+    let recipient = Address::generate(&env);
+    let expiration = env.ledger().sequence() + 100;
+    client.approve(&admin, &spender, &50, &expiration);
+
+    let result = client.try_transfer_from(&spender, &admin, &recipient, &100);
+    assert_eq!(result, Err(Ok(crate::errors::Error::InsufficientAllowance)));
+    assert_eq!(client.balance(&admin), 1000);
+    assert_eq!(client.balance(&recipient), 0);
+    assert_eq!(client.allowance(&admin, &spender), 50);
+}
+
 #[test]
 fn test_burn_from_expiration_at_current_ledger() {
     let env = Env::default();