@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/common-macros/src/tests/{storage.rs → storage/generate_storage.rs}

@@ -1,12 +1,12 @@
 use quote::quote;
 
-use crate::tests::test_helpers::{assert_panics_contains, non_enum_item_inputs};
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
 
 #[test]
 fn test_non_enum_input() {
-    for (case, input) in non_enum_item_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["enum"]) {
         assert_panics_contains(case, "failed to parse enum", || {
-            crate::storage::generate_storage(quote! {}, input.clone());
+            crate::storage::generate_storage(input.clone());
         });
     }
 }
@@ -36,7 +36,7 @@ fn test_tuple_variant_rejected() {
 
     for (case, input) in cases {
         assert_panics_contains(case, "only unit variants or named fields are supported", || {
-            crate::storage::generate_storage(quote! {}, input.clone());
+            crate::storage::generate_storage(input.clone());
         });
     }
 }
@@ -62,9 +62,20 @@ fn test_attribute_errors() {
                 }
             },
         ),
+        (
+            "invalid storage type with another valid storage type",
+            "failed to parse storage type",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[instance]
+                    Counter,
+                }
+            },
+        ),
         (
             "missing type param",
-            "failed to parse storage variant for Counter",
+            "failed to parse storage type for",
             quote! {
                 enum TestEnum {
                     #[instance]
@@ -74,7 +85,7 @@ fn test_attribute_errors() {
         ),
         (
             "invalid type param",
-            "failed to parse storage variant for",
+            "failed to parse storage type for",
             quote! {
                 enum TestEnum {
                     #[persistent(u32, String)]
@@ -86,7 +97,7 @@ fn test_attribute_errors() {
 
     for (case, expected, input) in cases_storage_type {
         assert_panics_contains(case, expected, || {
-            crate::storage::generate_storage(quote! {}, input.clone());
+            crate::storage::generate_storage(input.clone());
         });
     }
 
@@ -140,7 +151,7 @@ fn test_attribute_errors() {
 
     for (case, expected, input) in cases_default {
         assert_panics_contains(case, expected, || {
-            crate::storage::generate_storage(quote! {}, input.clone());
+            crate::storage::generate_storage(input.clone());
         });
     }
 
@@ -194,7 +205,7 @@ fn test_attribute_errors() {
 
     for (case, expected, input) in cases_name {
         assert_panics_contains(case, expected, || {
-            crate::storage::generate_storage(quote! {}, input.clone());
+            crate::storage::generate_storage(input.clone());
         });
     }
 
@@ -206,11 +217,22 @@ fn test_attribute_errors() {
                 Counter,
             }
         };
-        crate::storage::generate_storage(quote! {}, input);
+        crate::storage::generate_storage(input);
     });
 
     // Test #[no_ttl_extension] validation
     let cases_no_ttl = vec![
+        (
+            "no_ttl_extension does not accept arguments",
+            "does not accept arguments",
+            quote! {
+                enum TestEnum {
+                    #[persistent(u32)]
+                    #[no_ttl_extension(foo)]
+                    Counter,
+                }
+            },
+        ),
         (
             "multiple no_ttl_extension",
             "multiple #[no_ttl_extension]",
@@ -310,26 +332,7 @@ fn test_attribute_errors() {
 
     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());
+            crate::storage::generate_storage(input.clone());
         });
     }
 }
@@ -340,146 +343,68 @@ fn test_attribute_errors() {
 
 /// Comprehensive snapshot test covering all storage macro features:
 /// - All storage types: instance, persistent, temporary
-/// - Unit variants and named field variants
+/// - Unit variants and named field variants (single and multiple fields)
 /// - Default values (with and without)
-/// - TTL extension control (TTL extended by default for persistent storage, opt-out with #[no_ttl_extension])
+/// - TTL extension control (auto for persistent, 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
+/// - snake_case naming conversion (TempData -> temp_data)
+/// - Primitive vs non-primitive key types (by value vs by reference + clone)
+///
+/// Note: Primitive type detection is exhaustively tested in test_is_primitive_type_* unit tests.
+/// This snapshot only needs one of each to verify the generated code integrates correctly.
 #[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 storage with default value
             #[instance(u32)]
             #[default(0)]
             Counter,
 
-            /// Persistent storage with named field and default (has auto TTL by default)
+            /// Persistent storage with single field and default (auto TTL)
             #[persistent(String)]
-            #[default("hello".to_string())]
+            #[default(String::from_str(env, "hello"))]
             Message { sender: Address },
 
-            /// Temporary storage (no auto TTL for temporary)
+            /// Temporary storage with single field
             #[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
+            /// Custom #[name()] override
             #[persistent(Option<Address>)]
             #[name("custom_key_name")]
             OptionalData { key: BytesN<32> },
 
-            /// Temporary storage (no auto TTL for temporary)
+            /// Temporary storage unit variant (also tests snake_case: TempData -> temp_data)
             #[temporary(u64)]
             TempData,
 
-            /// Test snake_case naming: UserBalance -> user_balance
+            /// Primitive key type: passed by value, no clone
             #[persistent(u32)]
-            UserBalance { user: Address },
+            PrimitiveKey { key: u32 },
 
-            /// 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,
+            /// Non-primitive key type: passed by reference, cloned
+            #[instance(u32)]
+            NonPrimitiveKey { key: String },
 
-            /// Test Named variant: fields extracted in order
+            /// Multiple fields with mixed primitive/non-primitive types
             #[persistent(u32)]
             NamedVariant { first: u32, second: String, third: Address },
 
-            /// Test #[no_ttl_extension] opt-out for persistent storage
+            /// #[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 result = crate::storage::generate_storage(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/storage/is_primitive_type.rs

@@ -0,0 +1,48 @@
+//! Unit tests for the `is_primitive_type` function.
+
+use crate::storage::test::is_primitive_type_for_test;
+
+#[test]
+fn test_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!(is_primitive_type_for_test(&ty), "{ty_str} should be recognized as primitive");
+    }
+}
+
+#[test]
+fn test_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!(!is_primitive_type_for_test(&ty), "{ty_str} should NOT be recognized as primitive");
+    }
+}
+
+#[test]
+fn test_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!(!is_primitive_type_for_test(&ty), "{label} type {ty_str} should NOT be recognized as primitive");
+    }
+}

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

@@ -0,0 +1,16 @@
+mod extract_fields;
+mod gen_accessor_methods;
+mod gen_args;
+mod gen_enum_variant;
+mod gen_key;
+mod gen_params;
+mod generate_storage;
+mod is_primitive_type;
+mod parse_default;
+mod parse_name;
+mod parse_no_ttl_extension;
+mod parse_storage_type;
+mod storage_kind;
+mod test_setup;
+mod validate_attrs;
+mod variant_config;

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

@@ -0,0 +1,164 @@
+//! Unit tests for the `parse_default` function.
+
+use crate::storage::test::parse_default_for_test;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_no_default_returns_none() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_none());
+}
+
+#[test]
+fn test_parses_integer_default() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[default(42)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    let default = result.unwrap();
+    assert!(default.is_some());
+    assert_eq!(quote!(#default).to_string(), "42");
+}
+
+#[test]
+fn test_parses_zero_default() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[default(0)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    let default = result.unwrap();
+    assert!(default.is_some());
+    assert_eq!(quote!(#default).to_string(), "0");
+}
+
+#[test]
+fn test_parses_boolean_default() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(bool)]
+            #[default(true)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    let default = result.unwrap();
+    assert!(default.is_some());
+    assert_eq!(quote!(#default).to_string(), "true");
+}
+
+#[test]
+fn test_parses_method_call_default() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(String)]
+            #[default(String::from_str(env, "hello"))]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    let default = result.unwrap();
+    assert!(default.is_some());
+    let default_str = quote!(#default).to_string();
+    assert!(default_str.contains("String :: from_str"));
+}
+
+#[test]
+fn test_error_multiple_defaults() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[default(0)]
+            #[default(1)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("multiple default values specified"));
+}
+
+#[test]
+fn test_error_default_without_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[default]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse default value"));
+}
+
+#[test]
+fn test_error_default_empty_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[default()]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse default value"));
+}
+
+#[test]
+fn test_empty_attrs_returns_none() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_none());
+}
+
+#[test]
+fn test_parses_negative_default() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(i64)]
+            #[default(-100)]
+            Variant,
+        }
+    });
+
+    let result = parse_default_for_test(&attrs);
+    assert!(result.is_ok());
+    let default = result.unwrap();
+    assert!(default.is_some());
+    assert_eq!(quote!(#default).to_string(), "- 100");
+}

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

@@ -0,0 +1,159 @@
+//! Unit tests for the `parse_name` function.
+
+use crate::storage::test::parse_name_for_test;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_no_name_returns_none() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_none());
+}
+
+#[test]
+fn test_parses_custom_name() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name("custom_name")]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_ok());
+    let name = result.unwrap();
+    assert_eq!(name, Some("custom_name".to_string()));
+}
+
+#[test]
+fn test_parses_name_with_underscores() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name("my_custom_storage_key")]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_ok());
+    let name = result.unwrap();
+    assert_eq!(name, Some("my_custom_storage_key".to_string()));
+}
+
+#[test]
+fn test_error_multiple_names() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name("first")]
+            #[name("second")]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("multiple name attributes specified"));
+}
+
+#[test]
+fn test_error_name_without_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse name attribute"));
+}
+
+#[test]
+fn test_error_name_empty_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name()]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse name attribute"));
+}
+
+#[test]
+fn test_error_name_with_integer() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name(123)]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse name attribute"));
+}
+
+#[test]
+fn test_error_name_with_identifier() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name(some_ident)]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("failed to parse name attribute"));
+}
+
+#[test]
+fn test_empty_attrs_returns_none() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_none());
+}
+
+#[test]
+fn test_parses_name_with_special_chars() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[name("key_v2_beta")]
+            Variant,
+        }
+    });
+
+    let result = parse_name_for_test(&attrs);
+    assert!(result.is_ok());
+    let name = result.unwrap();
+    assert_eq!(name, Some("key_v2_beta".to_string()));
+}
+