@layerzerolabs/common-utils-macros-stellar-contracts 0.2.122

package/src/tests/storage/gen_key.rs

@@ -0,0 +1,108 @@
+//! Unit tests for the `gen_key` function.
+
+use crate::storage::test::gen_key_for_test;
+use quote::{format_ident, quote};
+
+use super::test_setup::{normalize, parse_variant, parse_variant_str};
+
+#[test]
+fn test_unit_variant_key() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            UnitVariant,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let generated_key = gen_key_for_test(&enum_name, &variant);
+    let expected = quote! { TestEnum::UnitVariant };
+    assert_eq!(normalize(generated_key), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_single_field_non_primitive() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            NamedVariant { owner: Address },
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let generated_key = gen_key_for_test(&enum_name, &variant);
+    // Non-primitive field identifiers should be cloned in the generated key.
+    let expected = quote! { TestEnum::NamedVariant(owner.clone()) };
+    assert_eq!(normalize(generated_key), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_single_field_primitive() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            NamedVariant { counter: u32 },
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let generated_key = gen_key_for_test(&enum_name, &variant);
+    // Primitive field identifiers should NOT be cloned in the generated key.
+    let expected = quote! { TestEnum::NamedVariant(counter) };
+    assert_eq!(normalize(generated_key), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_multiple_fields_mixed() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            MixedVariant { id: u64, name: String, count: i128 },
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let generated_key = gen_key_for_test(&enum_name, &variant);
+    // u64 and i128 are primitives (no clone), String is not (clone)
+    let expected = quote! { TestEnum::MixedVariant(id, name.clone(), count) };
+    assert_eq!(normalize(generated_key), normalize(expected));
+}
+
+#[test]
+fn test_uses_provided_enum_name() {
+    let variant = parse_variant(quote! {
+        enum Dummy {
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+    let enum_name = format_ident!("CustomEnumName");
+
+    let generated_key = gen_key_for_test(&enum_name, &variant);
+    let expected = quote! { CustomEnumName::Variant };
+    assert_eq!(normalize(generated_key), normalize(expected));
+}
+
+#[test]
+fn test_all_primitives_not_cloned() {
+    let primitives = ["u32", "i32", "u64", "i64", "u128", "i128", "bool"];
+
+    for ty in primitives {
+        let input = format!(
+            r#"
+            enum TestEnum {{
+                #[persistent(u32)]
+                Variant {{ key: {} }},
+            }}
+            "#,
+            ty
+        );
+        let variant = parse_variant_str(&input);
+        let enum_name = format_ident!("TestEnum");
+
+        let generated_key = gen_key_for_test(&enum_name, &variant);
+        let generated_str = generated_key.to_string();
+
+        assert!(!generated_str.contains("clone"), "primitive type {} should not be cloned, got: {}", ty, generated_str);
+    }
+}

package/src/tests/storage/gen_params.rs

@@ -0,0 +1,105 @@
+//! Unit tests for the `gen_params` function.
+
+use crate::storage::test::gen_params_for_test;
+use quote::quote;
+
+use super::test_setup::{normalize, parse_variant};
+
+#[test]
+fn test_unit_variant_only_env_param() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            UnitVariant,
+        }
+    });
+
+    let params = gen_params_for_test(&variant);
+    let expected = quote! { env: &soroban_sdk::Env };
+    assert_eq!(normalize(params), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_with_primitive_field_by_value() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: u32 },
+        }
+    });
+
+    let params = gen_params_for_test(&variant);
+    let expected = quote! { env: &soroban_sdk::Env, key: u32 };
+    assert_eq!(normalize(params), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_with_non_primitive_field_by_reference() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: Address },
+        }
+    });
+
+    let params = gen_params_for_test(&variant);
+    let expected = quote! { env: &soroban_sdk::Env, key: &Address };
+    assert_eq!(normalize(params), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_mixed_primitive_and_non_primitive() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            MixedVariant { id: u64, name: String, count: i128, address: Address },
+        }
+    });
+
+    let params = gen_params_for_test(&variant);
+    // u64 and i128 are primitives (by value), String and Address are not (by reference)
+    let expected = quote! { env: &soroban_sdk::Env, id: u64, name: &String, count: i128, address: &Address };
+    assert_eq!(normalize(params), normalize(expected));
+}
+
+#[test]
+fn test_all_primitive_types_by_value() {
+    let primitives = [
+        ("u32", "u32"),
+        ("i32", "i32"),
+        ("u64", "u64"),
+        ("i64", "i64"),
+        ("u128", "u128"),
+        ("i128", "i128"),
+        ("bool", "bool"),
+    ];
+
+    for (ty_str, expected_ty) in primitives {
+        let input = format!(
+            r#"
+            enum Test {{
+                #[persistent(u32)]
+                Variant {{ key: {} }},
+            }}
+            "#,
+            ty_str
+        );
+        let variant = parse_variant(input.parse().unwrap());
+        let params = gen_params_for_test(&variant);
+        let params_str = params.to_string();
+
+        // Should be by value (no &)
+        assert!(
+            params_str.contains(&format!("key : {}", expected_ty)),
+            "primitive type {} should be passed by value, got: {}",
+            ty_str,
+            params_str
+        );
+        assert!(
+            !params_str.contains(&format!("key : & {}", expected_ty)),
+            "primitive type {} should NOT be passed by reference, got: {}",
+            ty_str,
+            params_str
+        );
+    }
+}

package/src/tests/storage/generate_storage.rs

@@ -0,0 +1,410 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
+
+#[test]
+fn test_non_enum_input() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["enum"]) {
+        assert_panics_contains(case, "failed to parse enum", || {
+            crate::storage::generate_storage(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(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,
+                }
+            },
+        ),
+        (
+            "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 type for",
+            quote! {
+                enum TestEnum {
+                    #[instance]
+                    Counter,
+                }
+            },
+        ),
+        (
+            "invalid type param",
+            "failed to parse storage type 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(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(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(input.clone());
+        });
+    }
+
+    assert_panics_contains("unknown attribute", "unknown attribute", || {
+        let input = quote! {
+            enum TestEnum {
+                #[persistent(u32)]
+                #[unknown_attr]
+                Counter,
+            }
+        };
+        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]",
+            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(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 (single and multiple fields)
+/// - Default values (with and without)
+/// - TTL extension control (auto for persistent, opt-out with #[no_ttl_extension])
+/// - Custom name attribute
+/// - 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
+            #[instance(u32)]
+            #[default(0)]
+            Counter,
+
+            /// Persistent storage with single field and default (auto TTL)
+            #[persistent(String)]
+            #[default(String::from_str(env, "hello"))]
+            Message { sender: Address },
+
+            /// Temporary storage with single field
+            #[temporary(bool)]
+            Flag { key: String },
+
+            /// Persistent storage without fields or default
+            #[persistent(Address)]
+            Owner,
+
+            /// Custom #[name()] override
+            #[persistent(Option<Address>)]
+            #[name("custom_key_name")]
+            OptionalData { key: BytesN<32> },
+
+            /// Temporary storage unit variant (also tests snake_case: TempData -> temp_data)
+            #[temporary(u64)]
+            TempData,
+
+            /// Primitive key type: passed by value, no clone
+            #[persistent(u32)]
+            PrimitiveKey { key: u32 },
+
+            /// Non-primitive key type: passed by reference, cloned
+            #[instance(u32)]
+            NonPrimitiveKey { key: String },
+
+            /// Multiple fields with mixed primitive/non-primitive types
+            #[persistent(u32)]
+            NamedVariant { first: u32, second: String, third: Address },
+
+            /// #[no_ttl_extension] opt-out for persistent storage
+            #[persistent(u64)]
+            #[no_ttl_extension]
+            CachedValue { key: Address },
+        }
+    };
+
+    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);
+}

package/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/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;