@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

package/contracts/common-macros/src/tests/ownable.rs

@@ -0,0 +1,151 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
+// ============================================
+// Snapshot Test: Ownable Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_ownable_code() {
+    let input = quote! {
+        pub struct MyContract;
+    };
+    let result = crate::ownable::generate_ownable_impl(input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+#[test]
+fn snapshot_only_owner_preserves_function_signature() {
+    let input = quote! {
+        pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
+            Ok(value.clone())
+        }
+    };
+    let result = crate::ownable::prepend_only_owner_check(input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+// ============================================
+// prepend_only_owner_check Tests
+// ============================================
+
+/// Helper function to verify that the owner check is correctly inserted at the beginning of a function.
+fn assert_owner_check_inserted(input: TokenStream, test_name: &str) {
+    let result_tokens = crate::ownable::prepend_only_owner_check(input);
+    let output_fn: syn::ItemFn =
+        syn::parse2(result_tokens).unwrap_or_else(|e| panic!("{}: failed to parse output function: {}", test_name, e));
+
+    assert!(!output_fn.block.stmts.is_empty(), "{}: function body should contain at least one statement", test_name);
+
+    let first_stmt = &output_fn.block.stmts[0];
+    let expected_stmt = "utils::ownable::require_owner_auth::<Self>(my_custom_env);";
+    let actual_stmt = quote::quote!(#first_stmt).to_string().replace(" ", "");
+
+    assert_eq!(
+        actual_stmt, expected_stmt,
+        "{}: expected owner check statement '{}', but got '{}'",
+        test_name, expected_stmt, actual_stmt
+    );
+}
+
+#[test]
+fn test_only_owner_inserts_correct_code_at_the_beginning() {
+    let test_cases = vec![
+        ("Env by value", quote! { pub fn f(my_custom_env: Env) {} }),
+        ("Env not first param", quote! { pub fn f(x: u32, my_custom_env: &Env) {} }),
+        ("Qualified path (soroban_sdk::Env)", quote! { pub fn f(my_custom_env: soroban_sdk::Env) {} }),
+        ("Nested reference (&&Env)", quote! { pub fn f(my_custom_env: &&Env) {} }),
+    ];
+
+    for (description, input) in test_cases {
+        assert_owner_check_inserted(input, description);
+    }
+}
+
+#[test]
+fn test_only_owner_requires_env_param() {
+    // ============================================
+    // Error Cases: Missing/Invalid Env Argument Patterns
+    // ============================================
+    let cases = vec![
+        ("no Env param", quote! { pub fn admin_action(value: u32) {} }),
+        // Tuple pattern destructuring is not supported - must use simple identifier
+        ("tuple pattern", quote! { pub fn admin_action((env, _other): (&Env, u32)) {} }),
+        // Wildcard pattern (_) is not supported - must use named identifier
+        ("wildcard pattern", quote! { pub fn admin_action(_: &Env) {} }),
+        // Struct destructuring pattern is not supported
+        ("struct pattern", quote! { pub fn admin_action(Env { .. }: Env) {} }),
+    ];
+
+    for (case, input) in cases {
+        assert_panics_contains(case, "function must have an Env argument", || {
+            crate::ownable::prepend_only_owner_check(input.clone());
+        });
+    }
+}
+
+// ============================================
+// Error Cases: ownable macro non-struct input
+// ============================================
+
+#[test]
+fn test_ownable_rejects_non_struct_inputs() {
+    for (case, input) in non_struct_item_inputs() {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::ownable::generate_ownable_impl(input.clone());
+        });
+    }
+}
+
+// ============================================
+// is_env_type Unit Tests
+// ============================================
+
+#[test]
+fn test_is_env_type_recognizes_env_types() {
+    let env_types = [
+        "Env",
+        "&Env",
+        "&&Env",
+        "&mut Env",
+        "soroban_sdk::Env",
+        "&soroban_sdk::Env",
+        "some::deeply::nested::module::Env",
+    ];
+
+    for ty_str in env_types {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(crate::utils::is_env_type(&ty), "{ty_str} should be recognized as an Env type");
+    }
+}
+
+#[test]
+fn test_is_env_type_rejects_non_env_types() {
+    let non_env_types = ["u32", "bool", "String", "Address", "&u32", "soroban_sdk::Address"];
+
+    for ty_str in non_env_types {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::utils::is_env_type(&ty), "{ty_str} should NOT be recognized as an Env type");
+    }
+}
+
+#[test]
+fn test_is_env_type_rejects_other_type_variants() {
+    let other_variants = [
+        ("(Env, u32)", "tuple"),
+        ("[Env; 1]", "array"),
+        ("[Env]", "slice"),
+        ("Option<Env>", "generic"),
+        ("!", "never"),
+    ];
+
+    for (ty_str, label) in other_variants {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::utils::is_env_type(&ty), "{label} type {ty_str} should NOT be recognized as an Env type");
+    }
+}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__contract_impl__snapshot_generated_contract_impl_code.snap

@@ -0,0 +1,85 @@
+---
+source: contracts/common-macros/src/tests/contract_impl.rs
+assertion_line: 98
+expression: combined
+---
+// === Inherent Impl (no attr) ===
+
+#[soroban_sdk::contractimpl]
+impl MyContract {
+    /// Public method with Env - should have TTL extension
+    pub fn public_with_env(env: Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 2
+    }
+    /// Public method with qualified Env path - should have TTL extension
+    pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        42
+    }
+    /// Public method with Env not as first parameter - should have TTL extension
+    pub fn env_second(value: u32, env: Env) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 2
+    }
+    /// Public method without Env - should NOT have TTL extension
+    pub fn public_without_env(value: u32) -> u32 {
+        value * 4
+    }
+    /// Private method with Env - should NOT have TTL extension (not public)
+    fn private_with_env(env: Env, value: u32) -> u32 {
+        value * 5
+    }
+    /// Pub(crate) method with Env - should NOT have TTL extension (not fully public)
+    pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
+        value * 7
+    }
+}
+
+
+// === Trait Impl (no attr) ===
+
+#[soroban_sdk::contractimpl]
+impl SomeTrait for MyContract {
+    /// Trait method with Env - should have TTL extension
+    fn trait_method_with_env(env: Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 2
+    }
+    /// Trait method without Env - should NOT have TTL extension
+    fn trait_method_without_env(value: u32) -> u32 {
+        value * 4
+    }
+}
+
+
+// === Trait Impl (contracttrait attr) ===
+
+#[soroban_sdk::contractimpl(contracttrait)]
+impl AnotherTrait for MyContract {
+    /// Trait method with contracttrait attr - should have TTL extension
+    fn contracttrait_method(env: Env, value: u32) -> u32 {
+        if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(env) {
+            env.storage()
+                .instance()
+                .extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+        }
+        value * 3
+    }
+}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ownable__snapshot_generated_ownable_code.snap

@@ -0,0 +1,30 @@
+---
+source: contracts/common-macros/src/tests/ownable.rs
+assertion_line: 17
+expression: formatted
+---
+pub struct MyContract;
+use utils::ownable::Ownable as _;
+use utils::ownable::OwnableInitializer as _;
+/// Implement the OwnableInitializer trait for the contract.
+impl utils::ownable::OwnableInitializer for MyContract {
+    fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
+        <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(
+            env,
+            owner,
+        )
+    }
+}
+/// Implement the Ownable trait for the contract.
+#[soroban_sdk::contractimpl]
+impl utils::ownable::Ownable for MyContract {
+    fn owner(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
+        utils::ownable::DefaultOwnable::owner(env)
+    }
+    fn transfer_ownership(env: &soroban_sdk::Env, new_owner: &soroban_sdk::Address) {
+        utils::ownable::DefaultOwnable::transfer_ownership(env, new_owner)
+    }
+    fn renounce_ownership(env: &soroban_sdk::Env) {
+        utils::ownable::DefaultOwnable::renounce_ownership(env)
+    }
+}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__ownable__snapshot_only_owner_preserves_function_signature.snap

@@ -0,0 +1,9 @@
+---
+source: contracts/common-macros/src/tests/ownable.rs
+assertion_line: 28
+expression: formatted
+---
+pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
+    utils::ownable::require_owner_auth::<Self>(env);
+    Ok(value.clone())
+}