@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -0,0 +1,223 @@
+//! Unit tests for the `gen_accessor_methods` function.
+
+use crate::storage::test::gen_accessor_methods_for_test;
+use proc_macro2::Ident;
+use quote::{format_ident, quote, ToTokens};
+use syn::{ImplItem, ImplItemFn, ItemImpl, ReturnType, Type, Variant};
+
+use super::test_setup::{normalize, parse_variant};
+
+fn gen_impl(enum_name: &Ident, variant: &Variant) -> ItemImpl {
+    let methods = gen_accessor_methods_for_test(enum_name, variant);
+    syn::parse2::<ItemImpl>(quote! { impl #enum_name { #methods } }).expect("failed to parse generated methods")
+}
+
+fn impl_fn_names(item_impl: &ItemImpl) -> Vec<String> {
+    item_impl
+        .items
+        .iter()
+        .filter_map(|it| match it {
+            ImplItem::Fn(f) => Some(f.sig.ident.to_string()),
+            _ => None,
+        })
+        .collect()
+}
+
+fn find_fn<'a>(item_impl: &'a ItemImpl, name: &str) -> &'a ImplItemFn {
+    item_impl
+        .items
+        .iter()
+        .find_map(|it| match it {
+            ImplItem::Fn(f) if f.sig.ident == name => Some(f),
+            _ => None,
+        })
+        .unwrap_or_else(|| panic!("expected to find function '{name}' in generated impl"))
+}
+
+fn output_type(sig: &syn::Signature) -> Option<&Type> {
+    match &sig.output {
+        ReturnType::Default => None,
+        ReturnType::Type(_, ty) => Some(ty.as_ref()),
+    }
+}
+
+#[test]
+fn generates_all_expected_methods_for_unit_variant() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            Counter,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let item_impl = gen_impl(&enum_name, &variant);
+    let mut names = impl_fn_names(&item_impl);
+    names.sort();
+
+    // Getter + CRUD-ish methods + TTL extender are always generated.
+    assert_eq!(
+        names,
+        vec!["counter", "extend_counter_ttl", "has_counter", "remove_counter", "set_counter", "set_or_remove_counter",]
+    );
+}
+
+#[test]
+fn uses_correct_storage_accessor_for_each_kind() {
+    let enum_name = format_ident!("TestEnum");
+
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            Counter,
+        }
+    });
+    let instance = gen_accessor_methods_for_test(&enum_name, &variant);
+    let instance_norm = normalize(instance);
+    let expected_instance = normalize(quote!(env.storage().instance()));
+    assert!(instance_norm.contains(&expected_instance));
+
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            Counter,
+        }
+    });
+    let persistent = gen_accessor_methods_for_test(&enum_name, &variant);
+    let persistent_norm = normalize(persistent);
+    let expected_persistent = normalize(quote!(env.storage().persistent()));
+    assert!(persistent_norm.contains(&expected_persistent));
+
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[temporary(u32)]
+            Counter,
+        }
+    });
+    let temporary = gen_accessor_methods_for_test(&enum_name, &variant);
+    let temporary_norm = normalize(temporary);
+    let expected_temporary = normalize(quote!(env.storage().temporary()));
+    assert!(temporary_norm.contains(&expected_temporary));
+}
+
+#[test]
+fn persistent_includes_auto_ttl_and_can_be_disabled() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            Counter,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let methods = gen_accessor_methods_for_test(&enum_name, &variant);
+    let methods_str = normalize(methods);
+
+    assert!(
+        methods_str.contains("utils :: ttl_configurable :: extend_persistent_ttl"),
+        "persistent storage should include auto TTL extension"
+    );
+
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            Counter,
+        }
+    });
+    let methods = gen_accessor_methods_for_test(&enum_name, &variant);
+    let methods_str = normalize(methods);
+
+    assert!(
+        !methods_str.contains("utils :: ttl_configurable :: extend_persistent_ttl"),
+        "no_ttl_extension should disable auto TTL extension"
+    );
+}
+
+#[test]
+fn default_value_changes_getter_return_type_and_body() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            #[default(0)]
+            Counter,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let item_impl = gen_impl(&enum_name, &variant);
+    let getter = find_fn(&item_impl, "counter");
+
+    // With default, return type should be the value type directly, not Option<...>
+    let out = output_type(&getter.sig).expect("getter should have an explicit return type");
+    assert_eq!(normalize(out.to_token_stream()), normalize(quote!(u32)));
+
+    let body = normalize(getter.block.to_token_stream());
+    assert!(body.contains("unwrap_or"), "getter should apply default via unwrap_or(...)");
+}
+
+#[test]
+fn no_default_getter_returns_option() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            Counter,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let item_impl = gen_impl(&enum_name, &variant);
+    let getter = find_fn(&item_impl, "counter");
+
+    let out = output_type(&getter.sig).expect("getter should have an explicit return type");
+    assert_eq!(normalize(out.to_token_stream()), normalize(quote!(Option<u32>)));
+}
+
+#[test]
+fn snake_case_and_custom_name_attribute_are_applied() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            MyLongVariantName,
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let item_impl = gen_impl(&enum_name, &variant);
+    let names = impl_fn_names(&item_impl);
+
+    assert!(names.iter().any(|n| n == "my_long_variant_name"), "should convert to snake_case");
+    assert!(names.iter().any(|n| n == "set_my_long_variant_name"), "setter should use snake_case");
+
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            #[name("custom_name")]
+            Counter,
+        }
+    });
+    let item_impl = gen_impl(&enum_name, &variant);
+    let names = impl_fn_names(&item_impl);
+
+    assert!(names.iter().any(|n| n == "custom_name"), "should use custom name for getter");
+    assert!(names.iter().any(|n| n == "set_custom_name"), "should use custom name for setter");
+}
+
+#[test]
+fn named_variant_generates_expected_param_passing_rules() {
+    let variant = parse_variant(quote! {
+        enum TestEnum {
+            #[instance(u32)]
+            Nonce { nonce: u32, user: Address },
+        }
+    });
+    let enum_name = format_ident!("TestEnum");
+
+    let item_impl = gen_impl(&enum_name, &variant);
+    let getter = find_fn(&item_impl, "nonce");
+    let sig_norm = normalize(getter.sig.to_token_stream());
+
+    // Non-primitive types are passed by reference, primitives by value.
+    assert!(sig_norm.contains("nonce : u32"), "primitive field should be passed by value");
+    assert!(sig_norm.contains("user : & Address"), "non-primitive field should be passed by reference");
+}

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

@@ -0,0 +1,65 @@
+//! Unit tests for the `gen_args` function.
+
+use crate::storage::test::gen_args_for_test;
+use quote::quote;
+
+use super::test_setup::{normalize, parse_variant};
+
+#[test]
+fn test_unit_variant_only_env_arg() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            UnitVariant,
+        }
+    });
+
+    let args = gen_args_for_test(&variant);
+    let expected = quote! { env };
+    assert_eq!(normalize(args), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_single_field() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: Address },
+        }
+    });
+
+    let args = gen_args_for_test(&variant);
+    let expected = quote! { env, key };
+    assert_eq!(normalize(args), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_multiple_fields() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { first: u32, second: String, third: Address },
+        }
+    });
+
+    let args = gen_args_for_test(&variant);
+    let expected = quote! { env, first, second, third };
+    assert_eq!(normalize(args), normalize(expected));
+}
+
+#[test]
+fn test_args_do_not_include_types() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: SomeComplexType },
+        }
+    });
+
+    let args = gen_args_for_test(&variant);
+    let args_str = args.to_string();
+
+    // Args should only contain identifiers, not types
+    assert!(!args_str.contains("SomeComplexType"), "args should not include types");
+    assert!(args_str.contains("key"), "args should include field name");
+}

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

@@ -0,0 +1,78 @@
+//! Unit tests for the `gen_enum_variant` function.
+
+use crate::storage::test::gen_enum_variant_for_test;
+use crate::tests::test_helpers::assert_panics_contains;
+use quote::quote;
+
+use super::test_setup::{normalize, parse_variant};
+
+#[test]
+fn test_unit_variant() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            UnitVariant,
+        }
+    });
+
+    let generated = gen_enum_variant_for_test(&variant);
+    let expected = quote! { UnitVariant };
+    assert_eq!(normalize(generated), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_single_field() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { key: Address },
+        }
+    });
+
+    let generated = gen_enum_variant_for_test(&variant);
+    // Named fields become tuple variant with types only
+    let expected = quote! { NamedVariant(Address) };
+    assert_eq!(normalize(generated), normalize(expected));
+}
+
+#[test]
+fn test_named_variant_multiple_fields() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            NamedVariant { first: u32, second: String, third: Address },
+        }
+    });
+
+    let generated = gen_enum_variant_for_test(&variant);
+    // Multiple fields become tuple variant with all types
+    let expected = quote! { NamedVariant(u32, String, Address) };
+    assert_eq!(normalize(generated), normalize(expected));
+}
+
+#[test]
+fn test_tuple_variant_panics() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            TupleVariant(u32, String),
+        }
+    });
+
+    assert_panics_contains("tuple variant", "only unit variants or named fields are supported", || {
+        gen_enum_variant_for_test(&variant);
+    });
+}
+
+#[test]
+fn test_complex_generic_types() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            GenericVariant { key: BytesN<32>, value: Vec<u8> },
+        }
+    });
+
+    let generated = gen_enum_variant_for_test(&variant);
+    let expected = quote! { GenericVariant(BytesN<32>, Vec<u8>) };
+    assert_eq!(normalize(generated), normalize(expected));
+}

package/contracts/common-macros/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/contracts/common-macros/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
+        );
+    }
+}