@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

@@ -1,108 +0,0 @@
-//! 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/contracts/common-macros/src/tests/storage/gen_params.rs

@@ -1,105 +0,0 @@
-//! 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/contracts/common-macros/src/tests/storage/generate_storage.rs

@@ -1,410 +0,0 @@
-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/contracts/common-macros/src/tests/storage/is_primitive_type.rs

@@ -1,48 +0,0 @@
-//! 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

@@ -1,16 +0,0 @@
-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;