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

package/src/tests/storage/variant_config.rs

@@ -0,0 +1,226 @@
+//! Unit tests for the `VariantConfig` struct and its `TryFrom` implementation via wrapper functions.
+
+use crate::storage::test::{get_variant_config_for_test, get_variant_method_names_for_test};
+use quote::quote;
+
+use super::test_setup::parse_variant;
+
+// ============================================================================
+// TryFrom<&Variant> Tests
+// ============================================================================
+
+#[test]
+fn test_try_from_instance_variant() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            Counter,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.kind_name, "instance");
+    assert_eq!(config.value_type, "u32");
+    assert_eq!(config.name, "counter"); // snake_case conversion
+    assert!(!config.auto_ttl); // instance storage doesn't have auto TTL
+    assert!(!config.has_default);
+}
+
+#[test]
+fn test_try_from_persistent_variant() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(Address)]
+            Owner,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.kind_name, "persistent");
+    assert_eq!(config.value_type, "Address");
+    assert_eq!(config.name, "owner");
+    assert!(config.auto_ttl); // persistent has auto TTL by default
+    assert!(!config.has_default);
+}
+
+#[test]
+fn test_try_from_temporary_variant() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[temporary(bool)]
+            Flag,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.kind_name, "temporary");
+    assert_eq!(config.value_type, "bool");
+    assert_eq!(config.name, "flag");
+    assert!(!config.auto_ttl); // temporary doesn't have auto TTL
+    assert!(!config.has_default);
+}
+
+#[test]
+fn test_try_from_with_default() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[default(0)]
+            Counter,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert!(config.has_default);
+}
+
+#[test]
+fn test_try_from_with_custom_name() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[name("custom_name")]
+            Counter,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.name, "custom_name");
+}
+
+#[test]
+fn test_try_from_snake_case_conversion() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            MyLongVariantName,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.name, "my_long_variant_name");
+}
+
+#[test]
+fn test_try_from_persistent_with_no_ttl_extension() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[no_ttl_extension]
+            CachedValue,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_ok());
+    let config = config.unwrap();
+    assert_eq!(config.kind_name, "persistent");
+    assert!(!config.auto_ttl); // disabled by no_ttl_extension
+}
+
+#[test]
+fn test_try_from_error_no_ttl_extension_on_instance() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[no_ttl_extension]
+            Counter,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_err());
+    let err = config.unwrap_err();
+    assert!(err.contains("can only be used with #[persistent"));
+}
+
+#[test]
+fn test_try_from_error_no_ttl_extension_on_temporary() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[temporary(u32)]
+            #[no_ttl_extension]
+            TempData,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_err());
+    let err = config.unwrap_err();
+    assert!(err.contains("can only be used with #[persistent"));
+}
+
+#[test]
+fn test_try_from_error_unknown_attribute() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[persistent(u32)]
+            #[unknown_attr]
+            Counter,
+        }
+    });
+
+    let config = get_variant_config_for_test(&variant);
+    assert!(config.is_err());
+    let err = config.unwrap_err();
+    assert!(err.contains("unknown attribute"));
+}
+
+// ============================================================================
+// method_names() Tests
+// ============================================================================
+
+#[test]
+fn test_method_names_basic() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            Counter,
+        }
+    });
+
+    let result = get_variant_method_names_for_test(&variant);
+    assert!(result.is_ok());
+    let (getter, setter, remover, set_or_remove, has, ttl_extender) = result.unwrap();
+
+    assert_eq!(getter, "counter");
+    assert_eq!(setter, "set_counter");
+    assert_eq!(remover, "remove_counter");
+    assert_eq!(set_or_remove, "set_or_remove_counter");
+    assert_eq!(has, "has_counter");
+    assert_eq!(ttl_extender, "extend_counter_ttl");
+}
+
+#[test]
+fn test_method_names_with_custom_name() {
+    let variant = parse_variant(quote! {
+        enum Test {
+            #[instance(u32)]
+            #[name("custom")]
+            Counter,
+        }
+    });
+
+    let result = get_variant_method_names_for_test(&variant);
+    assert!(result.is_ok());
+    let (getter, setter, remover, set_or_remove, has, ttl_extender) = result.unwrap();
+
+    assert_eq!(getter, "custom");
+    assert_eq!(setter, "set_custom");
+    assert_eq!(remover, "remove_custom");
+    assert_eq!(set_or_remove, "set_or_remove_custom");
+    assert_eq!(has, "has_custom");
+    assert_eq!(ttl_extender, "extend_custom_ttl");
+}

package/src/tests/test_helpers.rs

@@ -0,0 +1,87 @@
+#![allow(unused_macros)]
+
+pub(in crate::tests) fn assert_panics_contains<F>(case: &str, expected_substring: &str, f: F)
+where
+    F: FnOnce() + std::panic::UnwindSafe,
+{
+    let result = std::panic::catch_unwind(f);
+    assert!(result.is_err(), "{case}: expected panic, but function returned normally");
+
+    let payload = result.expect_err("checked above");
+    let msg = if let Some(s) = payload.downcast_ref::<&str>() {
+        (*s).to_string()
+    } else if let Some(s) = payload.downcast_ref::<String>() {
+        s.clone()
+    } else {
+        format!("{payload:?}")
+    };
+
+    assert!(
+        msg.contains(expected_substring),
+        "{case}: expected panic message to contain '{expected_substring}', got '{msg}'"
+    );
+}
+
+pub(in crate::tests) fn filter_item_inputs_excluding_labels(
+    excluded: &[&str],
+) -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    item_inputs().into_iter().filter(|(label, _)| !excluded.iter().any(|x| x == label)).collect()
+}
+
+/// Canonical list of syntactically-valid `syn::Item` inputs.
+///
+/// Keep this list broad and reusable; other helpers should filter it by AST kind.
+pub(in crate::tests) fn item_inputs() -> Vec<(&'static str, proc_macro2::TokenStream)> {
+    vec![
+        (
+            "struct",
+            quote::quote! {
+                struct AStruct {
+                    field: u32,
+                }
+            },
+        ),
+        (
+            "enum",
+            quote::quote! {
+                enum AnEnum {
+                    Variant1,
+                    Variant2,
+                }
+            },
+        ),
+        ("function", quote::quote! { fn a_function() {} }),
+        ("macro invocation", quote::quote! { some_macro!(); }),
+        ("const item", quote::quote! { const A_CONST: u32 = 1; }),
+        ("static item", quote::quote! { static A_STATIC: u32 = 1; }),
+        ("use item", quote::quote! { use core::mem; }),
+        ("mod item", quote::quote! { mod a_module {} }),
+        ("extern crate", quote::quote! { extern crate core; }),
+        (
+            "union",
+            quote::quote! {
+                union AUnion {
+                    a: u32,
+                    b: u32,
+                }
+            },
+        ),
+        (
+            "impl block",
+            quote::quote! {
+                impl SomeType {
+                    fn method(&self) {}
+                }
+            },
+        ),
+        (
+            "trait",
+            quote::quote! {
+                trait ATrait {
+                    fn method(&self);
+                }
+            },
+        ),
+        ("type alias", quote::quote! { type AnAlias = u32; }),
+    ]
+}

package/src/tests/ttl_configurable.rs

@@ -0,0 +1,34 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
+
+// ============================================
+// Snapshot Test: TtlConfigurable Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_ttl_configurable_code() {
+    // Test with a public unit struct
+    let input = quote! {
+        pub struct MyContract {
+            some_field: u32,
+        }
+    };
+    let result = crate::ttl_configurable::generate_ttl_configurable_impl(input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+// ============================================
+// Error Cases: Non-Struct Input
+// ============================================
+
+#[test]
+fn test_ttl_configurable_rejects_non_struct_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::ttl_configurable::generate_ttl_configurable_impl(input.clone());
+        });
+    }
+}

package/src/tests/ttl_extendable.rs

@@ -0,0 +1,32 @@
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
+
+// ============================================
+// Snapshot Test: TtlExtendable Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_ttl_extendable_code() {
+    let input = quote! {
+        pub struct MyContract;
+    };
+
+    let result = crate::ttl_extendable::generate_ttl_extendable_impl(input);
+    let formatted = prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+    insta::assert_snapshot!(formatted);
+}
+
+// ============================================
+// Error Cases: Non-Struct Input
+// ============================================
+
+#[test]
+fn test_ttl_extendable_rejects_non_struct_inputs() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::ttl_extendable::generate_ttl_extendable_impl(input.clone());
+        });
+    }
+}

package/src/tests/upgradeable.rs

@@ -0,0 +1,169 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
+
+static CARGO_PKG_VERSION_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+/// Small RAII helper for temporarily mutating a single environment variable in tests.
+///
+/// Why this exists:
+/// - `generate_upgradeable_impl` reads `CARGO_PKG_VERSION` at runtime to decide whether to emit
+///   `soroban_sdk::contractmeta!(key = "binver", ...)`.
+/// - Tests need to set/unset that env var deterministically and then restore it to avoid polluting
+///   other tests (especially snapshot tests).
+/// - `Drop` guarantees restoration even if the test panics.
+struct EnvVarGuard {
+    key: &'static str,
+    prev: Option<String>,
+}
+
+impl EnvVarGuard {
+    /// Captures the current value of `key` (if any) so it can be restored on drop.
+    fn new(key: &'static str) -> Self {
+        Self { key, prev: std::env::var(key).ok() }
+    }
+
+    /// Sets the environment variable for the duration of this guard's lifetime.
+    fn set(&self, value: &str) {
+        std::env::set_var(self.key, value);
+    }
+
+    /// Removes the environment variable for the duration of this guard's lifetime.
+    fn remove(&self) {
+        std::env::remove_var(self.key);
+    }
+}
+
+impl Drop for EnvVarGuard {
+    /// Restores the original env var state captured in `new()`.
+    fn drop(&mut self) {
+        match &self.prev {
+            Some(v) => std::env::set_var(self.key, v),
+            None => std::env::remove_var(self.key),
+        }
+    }
+}
+
+// ============================================
+// Snapshot Test: Upgradeable Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generated_upgradeable_code() {
+    let _lock = CARGO_PKG_VERSION_LOCK.lock().expect("lock poisoned");
+    let input = quote! {
+        pub struct MyContract;
+    };
+
+    // Test default behavior (requires manual UpgradeableInternal impl)
+    let default_result = crate::upgradeable::generate_upgradeable_impl(TokenStream::new(), input.clone());
+    let default_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(default_result).expect("failed to parse generated code"));
+
+    // Test with no_migration (auto-generates UpgradeableInternal impl)
+    let no_migration_result = crate::upgradeable::generate_upgradeable_impl(quote! { no_migration }, input);
+    let no_migration_formatted =
+        prettyplease::unparse(&syn::parse2::<syn::File>(no_migration_result).expect("failed to parse generated code"));
+
+    let combined = format!(
+        "// ============================================\n\
+         // Default: requires manual UpgradeableInternal\n\
+         // ============================================\n\n\
+         {default_formatted}\n\
+         // ============================================\n\
+         // With no_migration: auto-generates impl\n\
+         // ============================================\n\n\
+         {no_migration_formatted}"
+    );
+
+    insta::assert_snapshot!(combined);
+}
+
+// ============================================
+// Error Cases: upgradeable macro non-struct input
+// ============================================
+
+#[test]
+fn test_upgradeable_skips_binver_when_version_is_0_0_0() {
+    let _lock = CARGO_PKG_VERSION_LOCK.lock().expect("lock poisoned");
+    let guard = EnvVarGuard::new("CARGO_PKG_VERSION");
+    guard.set("0.0.0");
+
+    let input = quote! {
+        pub struct MyContract;
+    };
+    let result = crate::upgradeable::generate_upgradeable_impl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    assert!(
+        !result_str.contains("contractmeta ! (key = \"binver\""),
+        "should skip binver contractmeta when version is 0.0.0. Got: {}",
+        result_str
+    );
+}
+
+#[test]
+fn test_upgradeable_skips_binver_when_version_is_missing() {
+    let _lock = CARGO_PKG_VERSION_LOCK.lock().expect("lock poisoned");
+    let guard = EnvVarGuard::new("CARGO_PKG_VERSION");
+    guard.remove();
+
+    let input = quote! {
+        pub struct MyContract;
+    };
+    let result = crate::upgradeable::generate_upgradeable_impl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    assert!(
+        !result_str.contains("contractmeta ! (key = \"binver\""),
+        "should skip binver contractmeta when version env is missing. Got: {}",
+        result_str
+    );
+}
+
+#[test]
+fn test_upgradeable_rejects_non_struct_inputs() {
+    let attr = TokenStream::new();
+    for (case, input) in filter_item_inputs_excluding_labels(&["struct"]) {
+        let attr_clone = attr.clone();
+        assert_panics_contains(case, "failed to parse struct", || {
+            crate::upgradeable::generate_upgradeable_impl(attr_clone, input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_upgradeable_emits_binver_when_version_is_set() {
+    let _lock = CARGO_PKG_VERSION_LOCK.lock().expect("lock poisoned");
+    let guard = EnvVarGuard::new("CARGO_PKG_VERSION");
+    guard.set("9.9.9");
+
+    let input = quote! {
+        pub struct MyContract;
+    };
+    let result = crate::upgradeable::generate_upgradeable_impl(TokenStream::new(), input);
+    let result_str = result.to_string();
+
+    assert!(
+        result_str.contains("contractmeta ! (key = \"binver\" , val = \"9.9.9\""),
+        "should emit binver contractmeta when version is set. Got: {}",
+        result_str
+    );
+}
+
+#[test]
+fn test_upgradeable_rejects_invalid_config_table_driven() {
+    let input = quote! { pub struct MyContract; };
+    let cases: Vec<(&str, TokenStream, &str)> = vec![
+        ("unknown option", quote! { not_migration }, "failed to parse upgradeable config"),
+        ("invalid attr syntax", quote! { 123 }, "failed to parse upgradeable config"),
+        ("extra tokens", quote! { no_migration, extra }, "failed to parse upgradeable config"),
+    ];
+
+    for (case, attr, expected) in cases {
+        assert_panics_contains(case, expected, || {
+            crate::upgradeable::generate_upgradeable_impl(attr.clone(), input.clone());
+        });
+    }
+}