@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

@@ -0,0 +1,45 @@
+---
+source: contracts/common-macros/src/tests/ttl_configurable.rs
+assertion_line: 20
+expression: formatted
+---
+#[common_macros::ownable]
+pub struct MyContract {
+    some_field: u32,
+}
+use utils::ttl::TtlConfigurable as _;
+#[soroban_sdk::contractimpl]
+impl utils::ttl::TtlConfigurable for MyContract {
+    #[common_macros::only_owner]
+    fn set_ttl_configs(
+        env: &soroban_sdk::Env,
+        instance: &Option<utils::ttl::TtlConfig>,
+        persistent: &Option<utils::ttl::TtlConfig>,
+    ) {
+        utils::ttl::DefaultTtlConfigurable::set_ttl_configs(env, instance, persistent);
+    }
+    fn ttl_configs(
+        env: &soroban_sdk::Env,
+    ) -> (Option<utils::ttl::TtlConfig>, Option<utils::ttl::TtlConfig>) {
+        utils::ttl::DefaultTtlConfigurable::ttl_configs(env)
+    }
+    #[common_macros::only_owner]
+    fn freeze_ttl_configs(env: &soroban_sdk::Env) {
+        utils::ttl::DefaultTtlConfigurable::freeze_ttl_configs(env);
+    }
+    fn is_ttl_configs_frozen(env: &soroban_sdk::Env) -> bool {
+        utils::ttl::DefaultTtlConfigurable::is_ttl_configs_frozen(env)
+    }
+}
+#[soroban_sdk::contractimpl]
+impl MyContract {
+    /// Extends the instance TTL.
+    ///
+    /// # Arguments
+    ///
+    /// * `threshold` - The threshold to extend the TTL.
+    /// * `extend_to` - The TTL to extend to.
+    pub fn extend_instance_ttl(env: &soroban_sdk::Env, threshold: u32, extend_to: u32) {
+        env.storage().instance().extend_ttl(threshold, extend_to);
+    }
+}

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

@@ -0,0 +1,485 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
+
+#[test]
+fn test_non_enum_input() {
+    for (case, input) in non_enum_item_inputs() {
+        assert_panics_contains(case, "failed to parse enum", || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_tuple_variant_rejected() {
+    let cases = vec![
+        (
+            "instance tuple variant",
+            quote! {
+                enum TestEnum {
+                    #[instance(u32)]
+                    TupleVariant(String, u32),
+                }
+            },
+        ),
+        (
+            "persistent tuple variant",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    TupleVariant(String, u32),
+                }
+            },
+        ),
+    ];
+
+    for (case, input) in cases {
+        assert_panics_contains(case, "only unit variants or named fields are supported", || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_attribute_errors() {
+    let cases_storage_type = vec![
+        (
+            "missing storage type",
+            "storage type must be specified exactly once",
+            quote! {
+                enum TestEnum { Counter }
+            },
+        ),
+        (
+            "multiple storage types",
+            "storage type must be specified exactly once",
+            quote! {
+                enum TestEnum {
+                    #[instance(u32)]
+                    #[persistent(u32)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "missing type param",
+            "failed to parse storage variant for Counter",
+            quote! {
+                enum TestEnum {
+                    #[instance]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "invalid type param",
+            "failed to parse storage variant for",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32, String)]
+                    Counter,
+                }
+            },
+        ),
+    ];
+
+    for (case, expected, input) in cases_storage_type {
+        assert_panics_contains(case, expected, || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+
+    let cases_default = vec![
+        (
+            "multiple defaults",
+            "multiple default values specified",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[default(0)]
+                    #[default(1)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "invalid default value",
+            "failed to parse default value",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[default(!@#$%)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "default without parens",
+            "failed to parse default value",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[default]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "default with empty parens",
+            "failed to parse default value",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[default()]
+                    Counter,
+                }
+            },
+        ),
+    ];
+
+    for (case, expected, input) in cases_default {
+        assert_panics_contains(case, expected, || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+
+    let cases_name = vec![
+        (
+            "multiple name attrs",
+            "multiple name attributes specified",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[name("foo")]
+                    #[name("bar")]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "invalid name attr",
+            "failed to parse name attribute",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[name(123)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "name without parens",
+            "failed to parse name attribute",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[name]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "name with empty parens",
+            "failed to parse name attribute",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[name()]
+                    Counter,
+                }
+            },
+        ),
+    ];
+
+    for (case, expected, input) in cases_name {
+        assert_panics_contains(case, expected, || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+
+    assert_panics_contains("unknown attribute", "unknown attribute", || {
+        let input = quote! {
+            enum TestEnum {
+                #[persistent(u32)]
+                #[unknown_attr]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input);
+    });
+
+    // Test #[no_ttl_extension] validation
+    let cases_no_ttl = vec![
+        (
+            "multiple no_ttl_extension",
+            "multiple #[no_ttl_extension]",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[no_ttl_extension]
+                    #[no_ttl_extension]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "triple no_ttl_extension",
+            "multiple #[no_ttl_extension]",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[no_ttl_extension]
+                    #[no_ttl_extension]
+                    #[no_ttl_extension]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension on instance",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[instance(u32)]
+                    #[no_ttl_extension]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension on instance with default",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[instance(u32)]
+                    #[default(0)]
+                    #[no_ttl_extension]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension before instance storage type",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[no_ttl_extension]
+                    #[instance(u32)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension on temporary",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[temporary(u32)]
+                    #[no_ttl_extension]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension before temporary storage type",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[no_ttl_extension]
+                    #[temporary(u32)]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "no_ttl_extension on instance in multi-variant enum",
+            "can only be used with #[persistent",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    ValidVariant,
+
+                    #[instance(u32)]
+                    #[no_ttl_extension]
+                    InvalidVariant,
+                }
+            },
+        ),
+    ];
+
+    for (case, expected, input) in cases_no_ttl {
+        assert_panics_contains(case, expected, || {
+            crate::storage::generate_storage(quote! {}, input.clone());
+        });
+    }
+
+    // Test that #[storage] does not accept arguments
+    let cases_attr = vec![
+        ("unknown arg", "does not accept arguments", quote! { unknown }),
+        ("key-value arg", "does not accept arguments", quote! { unknown = SomeType }),
+        ("function-like arg", "does not accept arguments", quote! { foo(bar) }),
+    ];
+    let input = quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            Counter,
+        }
+    };
+
+    for (case, expected, attr) in cases_attr {
+        assert_panics_contains(case, expected, || {
+            crate::storage::generate_storage(attr.clone(), input.clone());
+        });
+    }
+}
+
+// ============================================
+// Valid Cases: Snapshot Tests for Generated Code
+// ============================================
+
+/// Comprehensive snapshot test covering all storage macro features:
+/// - All storage types: instance, persistent, temporary
+/// - Unit variants and named field variants
+/// - Default values (with and without)
+/// - TTL extension control (TTL extended by default for persistent storage, opt-out with #[no_ttl_extension])
+/// - Custom name attribute
+/// - Function naming rules: snake_case conversion (UserBalance -> user_balance) and custom name override
+/// - Primitive type detection: u32/i64/bool passed by value, u8/usize/String/Vec/Address passed by reference
+/// - Clone behavior: primitive types not cloned, non-primitive types cloned in key construction
+/// - Field extraction: Unit variants have no fields, Named variants extract fields in order
+/// - Doc comments and visibility
+#[test]
+fn snapshot_generated_storage_code() {
+    let input = quote! {
+        /// Enum-level doc comment
+        pub enum StorageKeys {
+            /// Instance storage with default value (no auto TTL for instance)
+            #[instance(u32)]
+            #[default(0)]
+            Counter,
+
+            /// Persistent storage with named field and default (has auto TTL by default)
+            #[persistent(String)]
+            #[default("hello".to_string())]
+            Message { sender: Address },
+
+            /// Temporary storage (no auto TTL for temporary)
+            #[temporary(bool)]
+            Flag { key: String },
+
+            /// Persistent storage with multiple fields (no default)
+            #[persistent(Vec<u8>)]
+            Data { id: u64, name: String },
+
+            /// Persistent storage without fields or default
+            #[persistent(Address)]
+            Owner,
+
+            /// Persistent storage with custom name override
+            #[persistent(Option<Address>)]
+            #[name("custom_key_name")]
+            OptionalData { key: BytesN<32> },
+
+            /// Temporary storage (no auto TTL for temporary)
+            #[temporary(u64)]
+            TempData,
+
+            /// Test snake_case naming: UserBalance -> user_balance
+            #[persistent(u32)]
+            UserBalance { user: Address },
+
+            /// Test custom name override: #[name("custom")] -> custom
+            #[persistent(u32)]
+            #[name("custom")]
+            AnotherVariant { key: Address },
+
+            /// Test primitive types: passed by value, not cloned
+            #[persistent(u32)]
+            U32Value { key: u32 },
+            #[persistent(i64)]
+            I64Value { key: i64 },
+            #[persistent(bool)]
+            BoolValue { key: bool },
+
+            /// Test non-primitive types: passed by reference, cloned
+            #[persistent(u32)]
+            U8Value { key: u8 },
+            #[persistent(u32)]
+            UsizeValue { key: usize },
+            #[persistent(String)]
+            StringValue { key: String },
+            #[persistent(Vec<u32>)]
+            VecValue { key: Vec<u32> },
+            #[persistent(Address)]
+            AddressValue { key: Address },
+
+            /// Test Unit variant: no fields
+            #[persistent(u32)]
+            UnitVariant,
+
+            /// Test Named variant: fields extracted in order
+            #[persistent(u32)]
+            NamedVariant { first: u32, second: String, third: Address },
+
+            /// Test #[no_ttl_extension] opt-out for persistent storage
+            #[persistent(u64)]
+            #[no_ttl_extension]
+            CachedValue { key: Address },
+        }
+    };
+
+    let result = crate::storage::generate_storage(quote! {}, input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+// ============================================
+// is_primitive_type Unit Tests
+// ============================================
+
+#[test]
+fn test_is_primitive_type_recognizes_primitive_types() {
+    let primitives = ["u32", "i32", "u64", "i64", "u128", "i128", "bool"];
+    for ty_str in primitives {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(crate::storage::is_primitive_type(&ty), "{ty_str} should be recognized as primitive");
+    }
+}
+
+#[test]
+fn test_is_primitive_type_rejects_non_primitive_types() {
+    let non_primitives = [
+        "u8",    // not in primitive list
+        "usize", // not in primitive list
+        "String",
+        "Address",
+        "Vec<u8>",
+        "Option<u32>",
+        "std::u32", // multi-segment path
+        "soroban_sdk::Address",
+    ];
+
+    for ty_str in non_primitives {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::storage::is_primitive_type(&ty), "{ty_str} should NOT be recognized as primitive");
+    }
+}
+
+#[test]
+fn test_is_primitive_type_rejects_other_type_variants() {
+    let other_variants = [
+        ("&u32", "reference"),
+        ("&mut u32", "mutable reference"),
+        ("(u32, i32)", "tuple"),
+        ("[u32; 4]", "array"),
+        ("[u32]", "slice"),
+        ("!", "never"),
+    ];
+
+    for (ty_str, label) in other_variants {
+        let ty = syn::parse_str::<syn::Type>(ty_str).expect("failed to parse type");
+        assert!(!crate::storage::is_primitive_type(&ty), "{label} type {ty_str} should NOT be recognized as primitive");
+    }
+}

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

@@ -0,0 +1,93 @@
+#![allow(unused_macros)]
+
+pub(in crate::tests) fn assert_panics_contains<F>(case: &str, expected_substring: &str, f: F)
+where
+    F: FnOnce() + std::panic::UnwindSafe,
+{
+    let result = std::panic::catch_unwind(f);
+    assert!(result.is_err(), "{case}: expected panic, but function returned normally");
+
+    let payload = result.expect_err("checked above");
+    let msg = if let Some(s) = payload.downcast_ref::<&str>() {
+        (*s).to_string()
+    } else if let Some(s) = payload.downcast_ref::<String>() {
+        s.clone()
+    } else {
+        format!("{payload:?}")
+    };
+
+    assert!(
+        msg.contains(expected_substring),
+        "{case}: expected panic message to contain '{expected_substring}', got '{msg}'"
+    );
+}
+
+pub(in crate::tests) fn non_struct_item_inputs() -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    filter_item_inputs_excluding_labels(&["struct"])
+}
+
+pub(in crate::tests) fn non_enum_item_inputs() -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    filter_item_inputs_excluding_labels(&["enum"])
+}
+
+/// Canonical list of syntactically-valid `syn::Item` inputs.
+///
+/// Keep this list broad and reusable; other helpers should filter it by AST kind.
+pub(in crate::tests) fn item_inputs() -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    vec![
+        (
+            "struct",
+            quote::quote! {
+                struct AStruct {
+                    field: u32,
+                }
+            },
+        ),
+        (
+            "enum",
+            quote::quote! {
+                enum AnEnum {
+                    Variant1,
+                    Variant2,
+                }
+            },
+        ),
+        ("function", quote::quote! { fn a_function() {} }),
+        ("macro invocation", quote::quote! { some_macro!(); }),
+        ("const item", quote::quote! { const A_CONST: u32 = 1; }),
+        ("static item", quote::quote! { static A_STATIC: u32 = 1; }),
+        ("use item", quote::quote! { use core::mem; }),
+        ("mod item", quote::quote! { mod a_module {} }),
+        ("extern crate", quote::quote! { extern crate core; }),
+        (
+            "union",
+            quote::quote! {
+                union AUnion {
+                    a: u32,
+                    b: u32,
+                }
+            },
+        ),
+        (
+            "impl block",
+            quote::quote! {
+                impl SomeType {
+                    fn method(&self) {}
+                }
+            },
+        ),
+        (
+            "trait",
+            quote::quote! {
+                trait ATrait {
+                    fn method(&self);
+                }
+            },
+        ),
+        ("type alias", quote::quote! { type AnAlias = u32; }),
+    ]
+}
+
+fn filter_item_inputs_excluding_labels(excluded: &[&str]) -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    item_inputs().into_iter().filter(|(label, _)| !excluded.iter().any(|x| x == label)).collect()
+}

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

@@ -0,0 +1,34 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, non_struct_item_inputs};
+
+// ============================================
+// Snapshot Test: TtlConfigurable Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_ttl_configurable_code() {
+    // Test with a public unit struct
+    let input = quote! {
+        pub struct MyContract {
+            some_field: u32,
+        }
+    };
+    let result = crate::ttl_configurable::generate_ttl_configurable_impl(input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+// ============================================
+// Error Cases: Non-Struct Input
+// ============================================
+
+#[test]
+fn test_ttl_configurable_rejects_non_struct_inputs() {
+    for (case, input) in non_struct_item_inputs() {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::ttl_configurable::generate_ttl_configurable_impl(input.clone());
+        });
+    }
+}