@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/utils/src/tests/option_ext.rs

@@ -0,0 +1,18 @@
+use crate::{errors::OwnableError, option_ext::OptionExt, tests::test_helper::assert_panics_contains};
+use soroban_sdk::Env;
+
+#[test]
+fn unwrap_or_panic_some_returns_value() {
+    let env = Env::default();
+    let got = Some(123u32).unwrap_or_panic(&env, OwnableError::OwnerNotSet);
+    assert_eq!(got, 123);
+}
+
+#[test]
+fn unwrap_or_panic_none_panics_with_error() {
+    const EXPECTED: &str = "Error(Contract, #1031)"; // OwnerNotSet
+    assert_panics_contains("none unwrap_or_panic", EXPECTED, || {
+        let env = Env::default();
+        let _got: u32 = None::<u32>.unwrap_or_panic(&env, OwnableError::OwnerNotSet);
+    });
+}

package/contracts/utils/src/tests/ownable.rs

@@ -1,13 +1,12 @@
 use crate::{
+    auth::Auth,
     errors::OwnableError,
-    ownable::{
-        self, DefaultOwnable, DefaultOwnableStorage, Ownable, OwnableInitializer, OwnershipRenounced,
-        OwnershipTransferred,
-    },
+    option_ext::OptionExt,
+    ownable::{self, Ownable, OwnableInitializer, OwnableStorage, OwnershipRenounced, OwnershipTransferred},
     testing_utils::assert_event,
 };
 use soroban_sdk::{
-    contract, contractimpl, panic_with_error,
+    contract, contractimpl,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     Address, Env, IntoVal,
 };
@@ -30,48 +29,27 @@ impl Contract {
         ownable::enforce_owner_auth::<Self>(env)
     }
 
-    pub fn init_owner(env: &Env, owner: &Address) {
-        if DefaultOwnableStorage::has_owner(env) {
-            panic_with_error!(env, OwnableError::OwnerAlreadySet);
-        }
-        DefaultOwnableStorage::set_owner(env, owner);
-    }
-
     pub fn remove_owner(env: &Env) {
-        DefaultOwnableStorage::remove_owner(env);
-    }
-}
-
-#[contractimpl]
-impl Ownable for Contract {
-    fn owner(env: &Env) -> Option<Address> {
-        DefaultOwnable::owner(env)
-    }
-
-    fn transfer_ownership(env: &Env, new_owner: &Address) {
-        DefaultOwnable::transfer_ownership(env, new_owner);
+        OwnableStorage::remove_owner(env);
     }
 
-    fn renounce_ownership(env: &Env) {
-        DefaultOwnable::renounce_ownership(env);
+    pub fn reinit_owner(env: &Env, owner: &Address) {
+        Self::init_owner(env, owner);
     }
 }
 
-/// Contract that does not implement Ownable trait - for testing raw init_owner
-#[contract]
-pub struct NonOwnableContract;
-
+/// Auth implementation for the test contract - uses stored owner as authorizer.
 #[contractimpl]
-impl NonOwnableContract {
-    pub fn init(env: &Env, owner: &Address) {
-        DefaultOwnable::init_owner(env, owner);
-    }
-
-    pub fn owner(env: &Env) -> Option<Address> {
-        DefaultOwnable::owner(env)
+impl Auth for Contract {
+    fn authorizer(env: &Env) -> Address {
+        <Self as Ownable>::owner(env).unwrap_or_panic(env, OwnableError::OwnerNotSet)
     }
 }
 
+#[contractimpl(contracttrait)]
+impl Ownable for Contract {}
+impl OwnableInitializer for Contract {}
+
 // ============================================
 // auth: Owner authentication tests
 // ============================================
@@ -109,7 +87,7 @@ fn auth_non_owner_cannot_call() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn auth_require_owner_when_no_owner_set() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -187,7 +165,7 @@ fn transfer_ownership_to_same_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn transfer_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -251,7 +229,7 @@ fn renounce_ownership_with_event() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn renounce_after_renounce_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
@@ -330,41 +308,15 @@ fn chain_new_owner_can_transfer() {
 // ============================================
 
 #[test]
-fn init_owner_success() {
-    let env = Env::default();
-    let owner = Address::generate(&env);
-    let contract = env.register(NonOwnableContract, ());
-    let client = NonOwnableContractClient::new(&env, &contract);
-
-    assert_eq!(client.owner(), None);
-    client.init(&owner);
-    assert_eq!(client.owner(), Some(owner));
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1300)")]
-fn init_owner_already_set_fails() {
+#[should_panic(expected = "Error(Contract, #1030)")] // OwnerAlreadySet
+fn reinit_owner_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let new_owner = Address::generate(&env);
-    let contract = env.register(NonOwnableContract, ());
-    let client = NonOwnableContractClient::new(&env, &contract);
-
-    client.init(&owner);
-    client.init(&new_owner);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1300)")]
-fn init_owner_when_already_set_fails() {
-    let env = Env::default();
-    let owner = Address::generate(&env);
-    let new_owner = Address::generate(&env);
-
     let contract = env.register(Contract, (&owner,));
     let client = ContractClient::new(&env, &contract);
 
-    client.init_owner(&new_owner);
+    client.reinit_owner(&new_owner);
 }
 
 // ============================================
@@ -393,7 +345,7 @@ fn enforce_owner_auth_returns_owner() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1301)")]
+#[should_panic(expected = "Error(Contract, #1031)")] // OwnerNotSet
 fn enforce_owner_auth_no_owner_set_fails() {
     let env = Env::default();
     let owner = Address::generate(&env);