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

package/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/src/tests/storage/parse_name.rs

@@ -0,0 +1,158 @@
+//! 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()));
+}

package/src/tests/storage/parse_no_ttl_extension.rs

@@ -0,0 +1,124 @@
+//! Unit tests for the `parse_no_ttl_extension` function.
+
+use crate::storage::test::parse_no_ttl_extension_for_test;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_no_attribute_returns_false() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(!result.unwrap());
+}
+
+#[test]
+fn test_attribute_present_returns_true() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap());
+}
+
+#[test]
+fn test_attribute_before_storage_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[no_ttl_extension]
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(result.unwrap());
+}
+
+#[test]
+fn test_error_attribute_with_parens() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension()]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_attribute_with_value() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension(true)]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_attribute_with_key_value() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension = true]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("does not accept arguments"));
+}
+
+#[test]
+fn test_error_multiple_attributes() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            #[no_ttl_extension]
+            Variant,
+        }
+    });
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("multiple #[no_ttl_extension]"));
+}
+
+#[test]
+fn test_empty_attrs_returns_false() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_no_ttl_extension_for_test(&attrs);
+    assert!(result.is_ok());
+    assert!(!result.unwrap());
+}

package/src/tests/storage/parse_storage_type.rs

@@ -0,0 +1,174 @@
+//! Unit tests for the `parse_storage_type` function.
+
+use crate::storage::test::parse_storage_type_for_test;
+use crate::tests::test_helpers::assert_panics_contains;
+use quote::quote;
+
+use super::test_setup::parse_attrs;
+
+#[test]
+fn test_parses_instance_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "instance");
+    assert_eq!(quote!(#ty).to_string(), "u32");
+}
+
+#[test]
+fn test_parses_persistent_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Address)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "Address");
+}
+
+#[test]
+fn test_parses_temporary_storage() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[temporary(bool)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "temporary");
+    assert_eq!(quote!(#ty).to_string(), "bool");
+}
+
+#[test]
+fn test_parses_complex_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Option<Address>)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "Option < Address >");
+}
+
+#[test]
+fn test_parses_generic_type_with_multiple_params() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(Map<Address, u64>)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (_, ty) = result.unwrap();
+    assert_eq!(quote!(#ty).to_string(), "Map < Address , u64 >");
+}
+
+#[test]
+fn test_error_missing_storage_type() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[default(0)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_error_empty_attrs() {
+    let attrs: Vec<syn::Attribute> = vec![];
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_error_multiple_storage_types() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[persistent(u32)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(err.contains("storage type must be specified exactly once"));
+}
+
+#[test]
+fn test_panics_missing_type_param() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[instance]
+            Variant,
+        }
+    });
+
+    assert_panics_contains("missing type param", "failed to parse storage type", || {
+        let _ = parse_storage_type_for_test(&attrs);
+    });
+}
+
+#[test]
+fn test_panics_invalid_type_param() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            #[persistent(u32, String)]
+            Variant,
+        }
+    });
+
+    assert_panics_contains("multiple type params", "failed to parse storage type", || {
+        let _ = parse_storage_type_for_test(&attrs);
+    });
+}
+
+#[test]
+fn test_ignores_non_storage_attrs() {
+    let attrs = parse_attrs(quote! {
+        enum Test {
+            /// Doc comment
+            #[default(0)]
+            #[name("custom")]
+            #[persistent(u64)]
+            Variant,
+        }
+    });
+
+    let result = parse_storage_type_for_test(&attrs);
+    assert!(result.is_ok());
+    let (kind_name, ty) = result.unwrap();
+    assert_eq!(kind_name, "persistent");
+    assert_eq!(quote!(#ty).to_string(), "u64");
+}