@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -0,0 +1,662 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::tests::test_helpers::assert_panics_contains;
+
+// ============================================================================
+// Snapshot Tests
+// ============================================================================
+
+/// Comprehensive snapshot test for contractimpl_with_ttl macro:
+/// - Inherent impl: public methods with Env (adds TTL), private/pub(crate) methods (skipped)
+/// - Trait impl: all methods with Env get TTL extension
+/// - Qualified Env types (soroban_sdk::Env)
+/// - Env parameter not in first position
+/// - Methods without Env (skipped)
+#[test]
+fn snapshot_generated_contractimpl_code() {
+    // Test inherent impl with empty attr
+    let empty_attr = TokenStream::new();
+    let inherent_input = quote! {
+        impl MyContract {
+            /// Public method with Env - should have TTL extension
+            pub fn public_with_env(env: Env, value: u32) -> u32 {
+                value * 2
+            }
+
+            /// Public method with qualified Env path - should have TTL extension
+            pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
+                42
+            }
+
+            /// Public method with Env not as first parameter - should have TTL extension
+            pub fn env_second(value: u32, env: &Env) -> u32 {
+                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
+            }
+
+            /// Constructor method - should NOT have TTL extension
+            pub fn __constructor(env: &Env, value: u32) {
+                let _ = value * 2;
+            }
+        }
+    };
+
+    let inherent_result = crate::contract_ttl::contractimpl_with_ttl(empty_attr.clone(), inherent_input);
+    let inherent_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(inherent_result).expect("failed to parse generated code"));
+
+    // Test trait impl with empty attr
+    let trait_input = quote! {
+        impl SomeTrait for MyContract {
+            /// Trait method with Env - should have TTL extension
+            fn trait_method_with_env(env: Env, value: u32) -> u32 {
+                value * 2
+            }
+
+            /// Trait method without Env - should NOT have TTL extension
+            fn trait_method_without_env(value: u32) -> u32 {
+                value * 4
+            }
+
+            /// Trait method with macro attribute - should have TTL extension
+            #[common_macros::only_auth]
+            fn trait_method_with_only_auth_attribute(env: Env, value: u32) -> u32 {
+                value * 5
+            }
+        }
+    };
+
+    let trait_result = crate::contract_ttl::contractimpl_with_ttl(empty_attr, trait_input);
+    let trait_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(trait_result).expect("failed to parse generated code"));
+
+    // Test trait impl with contracttrait attr
+    let contracttrait_attr = quote! { contracttrait };
+    let contracttrait_input = quote! {
+        impl AnotherTrait for MyContract {
+            /// Trait method with contracttrait attr - should have TTL extension
+            fn contracttrait_method(env: &Env, value: u32) -> u32 {
+                value * 3
+            }
+        }
+    };
+
+    let contracttrait_result = crate::contract_ttl::contractimpl_with_ttl(contracttrait_attr, contracttrait_input);
+    let contracttrait_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(contracttrait_result).expect("failed to parse generated code"));
+
+    // Combine all for single snapshot
+    let combined = format!(
+        "// === Inherent Impl (no attr) ===\n\n{}\n\n// === Trait Impl (no attr) ===\n\n{}\n\n// === Trait Impl (contracttrait attr) ===\n\n{}",
+        inherent_formatted, trait_formatted, contracttrait_formatted
+    );
+
+    insta::assert_snapshot!(combined);
+}
+
+/// Comprehensive snapshot test for contracttrait_with_ttl macro:
+/// - Default methods with Env (adds TTL)
+/// - Abstract methods without body (skipped)
+/// - Methods without Env (skipped)
+/// - Qualified Env types (soroban_sdk::Env)
+/// - Env parameter not in first position
+#[test]
+fn snapshot_generated_contracttrait_code() {
+    // Test trait with empty attr
+    let empty_attr = TokenStream::new();
+    let trait_input = quote! {
+        pub trait MyTrait: Sized {
+            /// Default method with Env - should have TTL extension
+            fn default_with_env(env: Env, value: u32) -> u32 {
+                value * 2
+            }
+
+            /// Default method with qualified Env path - should have TTL extension
+            fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
+                42
+            }
+
+            /// Default method with Env not as first parameter - should have TTL extension
+            fn env_second(value: u32, env: &Env) -> u32 {
+                value * 2
+            }
+
+            /// Default method without Env - should NOT have TTL extension
+            fn default_without_env(value: u32) -> u32 {
+                value * 4
+            }
+
+            /// Abstract method with Env - should NOT have TTL extension (no body)
+            fn abstract_with_env(env: Env, value: u32) -> u32;
+
+            /// Abstract method without Env - should NOT have TTL extension (no body)
+            fn abstract_without_env(value: u32) -> u32;
+        }
+    };
+
+    let trait_result = crate::contract_ttl::contracttrait_with_ttl(empty_attr.clone(), trait_input);
+    let trait_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(trait_result).expect("failed to parse generated code"));
+
+    // Test trait with crate attr
+    let crate_attr = quote! { crate = "other_sdk" };
+    let trait_with_attr_input = quote! {
+        pub trait AnotherTrait {
+            /// Default method with Env - should have TTL extension
+            fn method_with_env(env: &Env, value: u32) -> u32 {
+                value * 3
+            }
+        }
+    };
+
+    let trait_with_attr_result = crate::contract_ttl::contracttrait_with_ttl(crate_attr, trait_with_attr_input);
+    let trait_with_attr_formatted = prettyplease::unparse(
+        &syn::parse2::<syn::File>(trait_with_attr_result).expect("failed to parse generated code"),
+    );
+
+    // Combine all for single snapshot
+    let combined = format!(
+        "// === Trait (no attr) ===\n\n{}\n\n// === Trait (crate attr) ===\n\n{}",
+        trait_formatted, trait_with_attr_formatted
+    );
+
+    insta::assert_snapshot!(combined);
+}
+
+// ============================================================================
+// Error Cases: Invalid Input
+// ============================================================================
+
+#[test]
+fn test_contractimpl_non_impl_block_input() {
+    let invalid_inputs = vec![
+        (
+            "struct",
+            quote! {
+                struct MyStruct {
+                    field: u32,
+                }
+            },
+        ),
+        (
+            "enum",
+            quote! {
+                enum MyEnum {
+                    Variant1,
+                    Variant2,
+                }
+            },
+        ),
+        ("function", quote! { fn a_function() {} }),
+        ("const item", quote! { const A_CONST: u32 = 1; }),
+        ("type alias", quote! { type AnAlias = u32; }),
+        (
+            "trait",
+            quote! {
+                trait ATrait {
+                    fn method(&self);
+                }
+            },
+        ),
+    ];
+
+    for (case, input) in invalid_inputs {
+        assert_panics_contains(case, "failed to parse impl block", || {
+            crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contracttrait_non_trait_input() {
+    let invalid_inputs = vec![
+        (
+            "struct",
+            quote! {
+                struct MyStruct {
+                    field: u32,
+                }
+            },
+        ),
+        (
+            "enum",
+            quote! {
+                enum MyEnum {
+                    Variant1,
+                    Variant2,
+                }
+            },
+        ),
+        ("function", quote! { fn a_function() {} }),
+        ("const item", quote! { const A_CONST: u32 = 1; }),
+        ("type alias", quote! { type AnAlias = u32; }),
+        (
+            "impl block",
+            quote! {
+                impl MyContract {
+                    fn method(&self) {}
+                }
+            },
+        ),
+    ];
+
+    for (case, input) in invalid_inputs {
+        assert_panics_contains(case, "failed to parse trait definition", || {
+            crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), input.clone());
+        });
+    }
+}
+
+// ============================================================================
+// Unit Tests: Attribute Handling
+// ============================================================================
+
+/// Verifies that contractimpl_with_ttl adds #[soroban_sdk::contractimpl] without parentheses when attr is empty
+#[test]
+fn test_contractimpl_adds_attribute_without_attr() {
+    let input = quote! {
+        impl MyContract {
+            pub fn my_method(env: Env) {}
+        }
+    };
+
+    let result = crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    assert!(
+        result_str.contains("# [soroban_sdk :: contractimpl]"),
+        "should add #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty. Got: {}",
+        result_str
+    );
+    assert!(
+        !result_str.contains("contractimpl ()"),
+        "should NOT have empty parentheses when attr is empty. Got: {}",
+        result_str
+    );
+}
+
+/// Verifies that contractimpl_with_ttl adds #[soroban_sdk::contractimpl(attr)] when attr is provided
+#[test]
+fn test_contractimpl_adds_attribute_with_attr() {
+    let input = quote! {
+        impl SomeTrait for MyContract {
+            fn my_method(env: Env) {}
+        }
+    };
+
+    let attr = quote! { contracttrait };
+    let result = crate::contract_ttl::contractimpl_with_ttl(attr, input);
+    let result_str = result.to_string();
+
+    assert!(
+        result_str.contains("contractimpl (contracttrait)"),
+        "should add #[soroban_sdk::contractimpl(contracttrait)] attribute. Got: {}",
+        result_str
+    );
+}
+
+/// Verifies that contracttrait_with_ttl adds #[soroban_sdk::contracttrait] without parentheses when attr is empty
+#[test]
+fn test_contracttrait_adds_attribute_without_attr() {
+    let input = quote! {
+        pub trait MyTrait {
+            fn my_method(env: Env) {}
+        }
+    };
+
+    let result = crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    assert!(
+        result_str.contains("# [soroban_sdk :: contracttrait]"),
+        "should add #[soroban_sdk::contracttrait] attribute without parentheses when attr is empty. Got: {}",
+        result_str
+    );
+    assert!(
+        !result_str.contains("contracttrait ()"),
+        "should NOT have empty parentheses when attr is empty. Got: {}",
+        result_str
+    );
+}
+
+/// Verifies that contracttrait_with_ttl adds #[soroban_sdk::contracttrait(attr)] when attr is provided
+#[test]
+fn test_contracttrait_adds_attribute_with_attr() {
+    let input = quote! {
+        pub trait MyTrait {
+            fn my_method(env: Env) {}
+        }
+    };
+
+    let attr = quote! { crate = "my_crate" };
+    let result = crate::contract_ttl::contracttrait_with_ttl(attr, input);
+    let result_str = result.to_string();
+
+    assert!(
+        result_str.contains("contracttrait (crate = \"my_crate\")"),
+        "should add #[soroban_sdk::contracttrait(crate = \"my_crate\")] attribute. Got: {}",
+        result_str
+    );
+}
+
+// ============================================================================
+// TTL Extension Test Infrastructure
+// ============================================================================
+
+/// Expected TTL extension behavior for a test case
+#[derive(Clone)]
+enum TtlExpectation {
+    /// TTL extension should NOT be inserted
+    None,
+    /// TTL extension should be inserted with the given env patterns
+    /// - `instance_arg`: pattern in `TtlConfigStorage::instance(...)` (e.g., "& env" for owned, "env" for ref)
+    /// - `storage_ident`: identifier for `.storage()` call
+    Present { instance_arg: &'static str, storage_ident: &'static str },
+}
+
+/// Test runner for contractimpl_with_ttl TTL behavior
+struct ImplTtlTestCase {
+    name: &'static str,
+    input: TokenStream,
+    expectation: TtlExpectation,
+}
+
+impl ImplTtlTestCase {
+    fn expect_ttl(
+        name: &'static str,
+        input: TokenStream,
+        instance_arg: &'static str,
+        storage_ident: &'static str,
+    ) -> Self {
+        Self { name, input, expectation: TtlExpectation::Present { instance_arg, storage_ident } }
+    }
+
+    fn expect_no_ttl(name: &'static str, input: TokenStream) -> Self {
+        Self { name, input, expectation: TtlExpectation::None }
+    }
+
+    fn run(&self) {
+        let result = crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), self.input.clone());
+        let result_str = result.to_string();
+        assert_ttl_expectation(&self.expectation, &result_str, self.name);
+    }
+}
+
+/// Test runner for contracttrait_with_ttl TTL behavior
+struct TraitTtlTestCase {
+    name: &'static str,
+    input: TokenStream,
+    expectation: TtlExpectation,
+}
+
+impl TraitTtlTestCase {
+    fn expect_ttl(
+        name: &'static str,
+        input: TokenStream,
+        instance_arg: &'static str,
+        storage_ident: &'static str,
+    ) -> Self {
+        Self { name, input, expectation: TtlExpectation::Present { instance_arg, storage_ident } }
+    }
+
+    fn expect_no_ttl(name: &'static str, input: TokenStream) -> Self {
+        Self { name, input, expectation: TtlExpectation::None }
+    }
+
+    fn run(&self) {
+        let result = crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), self.input.clone());
+        let result_str = result.to_string();
+        assert_ttl_expectation(&self.expectation, &result_str, self.name);
+    }
+}
+
+fn assert_ttl_expectation(expectation: &TtlExpectation, result_str: &str, name: &str) {
+    let has_ttl = result_str.contains("TtlConfigStorage :: instance");
+
+    match expectation {
+        TtlExpectation::None => {
+            assert!(!has_ttl, "{}: TTL extension should NOT be present, but was found", name);
+        }
+        TtlExpectation::Present { instance_arg, storage_ident } => {
+            assert!(has_ttl, "{}: TTL extension should be present, but was not found", name);
+            assert!(result_str.contains("extend_ttl"), "{}: should insert extend_ttl call", name);
+
+            let instance_pattern = format!("TtlConfigStorage :: instance ({})", instance_arg);
+            assert!(
+                result_str.contains(&instance_pattern),
+                "{}: expected '{}' in TtlConfigStorage::instance call. Got: {}",
+                name,
+                instance_arg,
+                result_str
+            );
+
+            let storage_pattern = format!("{} . storage ()", storage_ident);
+            assert!(result_str.contains(&storage_pattern), "{}: expected '{}.storage()' call", name, storage_ident);
+        }
+    }
+}
+
+// ============================================================================
+// TTL Extension Tests: contractimpl_with_ttl
+// ============================================================================
+
+#[test]
+fn test_impl_ttl_extension_with_owned_env() {
+    ImplTtlTestCase::expect_ttl(
+        "public method with owned Env",
+        quote! {
+            impl MyContract {
+                pub fn my_method(env: Env) { let x = 1; }
+            }
+        },
+        "& env", // instance takes reference
+        "env",   // storage called on ident
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_ttl_extension_with_ref_env() {
+    ImplTtlTestCase::expect_ttl(
+        "public method with ref Env",
+        quote! {
+            impl MyContract {
+                pub fn my_method(env: &Env) { let x = 1; }
+            }
+        },
+        "env", // instance takes ident directly (already a ref)
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_ttl_extension_with_custom_env_ident_owned() {
+    ImplTtlTestCase::expect_ttl(
+        "custom Env identifier (owned)",
+        quote! {
+            impl MyContract {
+                pub fn my_method(my_custom_env: Env) { let x = 1; }
+            }
+        },
+        "& my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_ttl_extension_with_custom_env_ident_ref() {
+    ImplTtlTestCase::expect_ttl(
+        "custom Env identifier (ref)",
+        quote! {
+            impl MyContract {
+                pub fn my_method(my_custom_env: &Env) { let x = 1; }
+            }
+        },
+        "my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_ttl_extension_for_trait_impl_owned_env() {
+    ImplTtlTestCase::expect_ttl(
+        "trait impl method with owned Env",
+        quote! {
+            impl SomeTrait for MyContract {
+                fn trait_method(env: Env) { let x = 1; }
+            }
+        },
+        "& env",
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_ttl_extension_for_trait_impl_ref_env() {
+    ImplTtlTestCase::expect_ttl(
+        "trait impl method with ref Env",
+        quote! {
+            impl SomeTrait for MyContract {
+                fn trait_method(env: &Env) { let x = 1; }
+            }
+        },
+        "env",
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_no_ttl_extension_for_private_method() {
+    ImplTtlTestCase::expect_no_ttl(
+        "private method with Env",
+        quote! {
+            impl MyContract {
+                fn private_method(env: Env) { let x = 1; }
+            }
+        },
+    )
+    .run();
+}
+
+#[test]
+fn test_impl_no_ttl_extension_without_env_param() {
+    ImplTtlTestCase::expect_no_ttl(
+        "public method without Env",
+        quote! {
+            impl MyContract {
+                pub fn no_env_method(value: u32) -> u32 { value }
+            }
+        },
+    )
+    .run();
+}
+
+// ============================================================================
+// TTL Extension Tests: contracttrait_with_ttl
+// ============================================================================
+
+#[test]
+fn test_trait_ttl_extension_with_owned_env() {
+    TraitTtlTestCase::expect_ttl(
+        "default method with owned Env",
+        quote! {
+            trait MyTrait {
+                fn my_method(env: Env) { let x = 1; }
+            }
+        },
+        "& env", // instance takes reference
+        "env",   // storage called on ident
+    )
+    .run();
+}
+
+#[test]
+fn test_trait_ttl_extension_with_ref_env() {
+    TraitTtlTestCase::expect_ttl(
+        "default method with ref Env",
+        quote! {
+            trait MyTrait {
+                fn my_method(env: &Env) { let x = 1; }
+            }
+        },
+        "env", // instance takes ident directly (already a ref)
+        "env",
+    )
+    .run();
+}
+
+#[test]
+fn test_trait_ttl_extension_with_custom_env_ident_owned() {
+    TraitTtlTestCase::expect_ttl(
+        "custom Env identifier (owned)",
+        quote! {
+            trait MyTrait {
+                fn my_method(my_custom_env: Env) { let x = 1; }
+            }
+        },
+        "& my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_trait_ttl_extension_with_custom_env_ident_ref() {
+    TraitTtlTestCase::expect_ttl(
+        "custom Env identifier (ref)",
+        quote! {
+            trait MyTrait {
+                fn my_method(my_custom_env: &Env) { let x = 1; }
+            }
+        },
+        "my_custom_env",
+        "my_custom_env",
+    )
+    .run();
+}
+
+#[test]
+fn test_trait_no_ttl_extension_for_abstract_method() {
+    TraitTtlTestCase::expect_no_ttl(
+        "abstract method with Env (no body)",
+        quote! {
+            trait MyTrait {
+                fn abstract_method(env: Env) -> u32;
+            }
+        },
+    )
+    .run();
+}
+
+#[test]
+fn test_trait_no_ttl_extension_without_env_param() {
+    TraitTtlTestCase::expect_no_ttl(
+        "default method without Env",
+        quote! {
+            trait MyTrait {
+                fn no_env_method(value: u32) -> u32 { value }
+            }
+        },
+    )
+    .run();
+}

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

@@ -1,6 +1,6 @@
-mod contract_impl;
+mod auth;
+mod contract_ttl;
 mod error;
-mod ownable;
 mod storage;
 mod test_helpers;
 mod ttl_configurable;

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

@@ -0,0 +1,20 @@
+---
+source: contracts/common-macros/src/tests/auth.rs
+assertion_line: 33
+expression: formatted
+---
+pub struct MyContract;
+use utils::{auth::Auth as _, multisig::Multisig as _};
+#[doc(hidden)]
+mod __multisig_impl_my_contract {
+    use super::*;
+    use utils::{auth::Auth, multisig::Multisig};
+    #[common_macros::contract_impl]
+    impl Auth for MyContract {
+        fn authorizer(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+            env.current_contract_address()
+        }
+    }
+    #[common_macros::contract_impl(contracttrait)]
+    impl Multisig for MyContract {}
+}