@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

package/contracts/utils/src/tests/ttl.rs

@@ -1,421 +0,0 @@
-extern crate std;
-
-use crate::errors::TtlError;
-use crate::ttl::{
-    DefaultTtlConfigurable, TtlConfig, TtlConfigStorage, TtlConfigurable, DEFAULT_INSTANCE_TTL, DEFAULT_PERSISTENT_TTL,
-    MAX_TTL,
-};
-use soroban_sdk::{contract, contractimpl, Address, Env};
-
-// ============================================
-// Test Contract for TTL functionality
-// ============================================
-
-#[contract]
-pub struct TtlTestContract;
-
-#[contractimpl]
-impl TtlTestContract {
-    // TtlConfigStorage storage tests
-    pub fn frozen(env: &Env) -> bool {
-        TtlConfigStorage::frozen(env)
-    }
-
-    pub fn set_frozen(env: &Env, value: bool) {
-        TtlConfigStorage::set_frozen(env, &value);
-    }
-
-    pub fn instance_ttl(env: &Env) -> TtlConfig {
-        TtlConfigStorage::instance(env).unwrap_or(DEFAULT_INSTANCE_TTL)
-    }
-
-    pub fn set_instance_ttl(env: &Env, config: TtlConfig) {
-        TtlConfigStorage::set_instance(env, &config);
-    }
-
-    pub fn has_instance_ttl(env: &Env) -> bool {
-        TtlConfigStorage::has_instance(env)
-    }
-
-    pub fn remove_instance_ttl(env: &Env) {
-        TtlConfigStorage::remove_instance(env);
-    }
-
-    pub fn remove_persistent_ttl(env: &Env) {
-        TtlConfigStorage::remove_persistent(env);
-    }
-
-    pub fn persistent_ttl(env: &Env) -> TtlConfig {
-        TtlConfigStorage::persistent(env).unwrap_or(DEFAULT_PERSISTENT_TTL)
-    }
-
-    pub fn set_persistent_ttl(env: &Env, config: TtlConfig) {
-        TtlConfigStorage::set_persistent(env, &config);
-    }
-
-    pub fn has_persistent_ttl(env: &Env) -> bool {
-        TtlConfigStorage::has_persistent(env)
-    }
-
-    // DefaultTtlConfigurable tests
-    pub fn configurable_set_ttl_configs(env: &Env, instance: Option<TtlConfig>, persistent: Option<TtlConfig>) {
-        DefaultTtlConfigurable::set_ttl_configs(env, &instance, &persistent);
-    }
-
-    pub fn configurable_ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
-        DefaultTtlConfigurable::ttl_configs(env)
-    }
-
-    pub fn configurable_freeze_ttl_configs(env: &Env) {
-        DefaultTtlConfigurable::freeze_ttl_configs(env);
-    }
-
-    pub fn is_ttl_configs_frozen(env: &Env) -> bool {
-        DefaultTtlConfigurable::is_ttl_configs_frozen(env)
-    }
-}
-
-fn setup_contract() -> (Env, Address, TtlTestContractClient<'static>) {
-    let env = Env::default();
-    let contract_id = env.register(TtlTestContract, ());
-    let client = TtlTestContractClient::new(&env, &contract_id);
-    (env, contract_id, client)
-}
-
-// ============================================
-// TtlConfig Struct Tests
-// ============================================
-
-#[test]
-fn test_ttl_config_new() {
-    let config = TtlConfig::new(100, 200);
-    assert_eq!(config.threshold, 100);
-    assert_eq!(config.extend_to, 200);
-}
-
-#[test]
-fn test_ttl_config_is_valid() {
-    // Valid configs
-    assert!(TtlConfig::new(100, 200).is_valid(300)); // threshold < extend_to < max
-    assert!(TtlConfig::new(100, 100).is_valid(200)); // threshold == extend_to
-    assert!(TtlConfig::new(100, 200).is_valid(200)); // extend_to == max
-    assert!(TtlConfig::new(100, 100).is_valid(100)); // all equal
-    assert!(TtlConfig::new(0, 0).is_valid(0)); // all zeros
-    assert!(TtlConfig::new(0, 0).is_valid(100)); // zero config with non-zero max
-    assert!(TtlConfig::new(0, 100).is_valid(100)); // threshold at minimum
-    assert!(TtlConfig::new(99, 100).is_valid(100)); // threshold just below extend_to
-    assert!(TtlConfig::new(MAX_TTL - 1, MAX_TTL).is_valid(MAX_TTL)); // large values
-    assert!(TtlConfig::new(MAX_TTL, MAX_TTL).is_valid(MAX_TTL)); // max values
-
-    // Invalid configs
-    assert!(!TtlConfig::new(200, 100).is_valid(300)); // threshold > extend_to
-    assert!(!TtlConfig::new(100, 400).is_valid(300)); // extend_to > max
-    assert!(!TtlConfig::new(100, 100).is_valid(99)); // extend_to > max
-}
-
-#[test]
-fn test_default_ttl_configs_are_valid() {
-    assert!(DEFAULT_INSTANCE_TTL.is_valid(MAX_TTL));
-    assert!(DEFAULT_PERSISTENT_TTL.is_valid(MAX_TTL));
-}
-
-// ============================================
-// TtlConfigStorage Storage Tests
-// ============================================
-
-#[test]
-fn test_ttl_config_data_defaults() {
-    let (_, _, client) = setup_contract();
-
-    // Default frozen state should be false
-    assert!(!client.frozen());
-
-    // Default TTLs should be returned when not set
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-
-    // has_* should return false initially
-    assert!(!client.has_instance_ttl());
-    assert!(!client.has_persistent_ttl());
-}
-
-#[test]
-fn test_ttl_config_data_set_get_remove() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    // Set and verify instance
-    client.set_instance_ttl(&instance_cfg);
-    assert!(client.has_instance_ttl());
-    assert_eq!(client.instance_ttl(), instance_cfg);
-
-    // Set and verify persistent
-    client.set_persistent_ttl(&persistent_cfg);
-    assert!(client.has_persistent_ttl());
-    assert_eq!(client.persistent_ttl(), persistent_cfg);
-
-    // Remove and verify defaults return
-    client.remove_instance_ttl();
-    assert!(!client.has_instance_ttl());
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-
-    // Remove persistent
-    client.remove_persistent_ttl();
-    assert!(!client.has_persistent_ttl());
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-#[test]
-fn test_ttl_config_data_frozen() {
-    let (_, _, client) = setup_contract();
-
-    assert!(!client.frozen());
-
-    client.set_frozen(&true);
-    assert!(client.frozen());
-
-    client.set_frozen(&false);
-    assert!(!client.frozen());
-}
-
-#[test]
-fn test_ttl_config_data_independent_storage() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(100, 200);
-    let persistent_cfg = TtlConfig::new(300, 400);
-
-    // Set each independently and verify others unchanged
-    client.set_instance_ttl(&instance_cfg);
-    assert_eq!(client.instance_ttl(), instance_cfg);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-
-    client.set_persistent_ttl(&persistent_cfg);
-    assert_eq!(client.instance_ttl(), instance_cfg);
-    assert_eq!(client.persistent_ttl(), persistent_cfg);
-}
-
-#[test]
-fn test_ttl_config_data_remove_all() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    // Set all configs
-    client.set_instance_ttl(&instance_cfg);
-    client.set_persistent_ttl(&persistent_cfg);
-
-    // Verify all are set
-    assert!(client.has_instance_ttl());
-    assert!(client.has_persistent_ttl());
-
-    // Remove all
-    client.remove_instance_ttl();
-    client.remove_persistent_ttl();
-
-    // Verify all return to defaults
-    assert!(!client.has_instance_ttl());
-    assert!(!client.has_persistent_ttl());
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-#[test]
-fn test_ttl_config_data_remove_when_not_set() {
-    let (_, _, client) = setup_contract();
-
-    // Removing when not set should not panic
-    client.remove_instance_ttl();
-    client.remove_persistent_ttl();
-
-    // Should still return defaults
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Basic Operations
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_initial_state() {
-    let (_, _, client) = setup_contract();
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert!(instance.is_none());
-    assert!(persistent.is_none());
-
-    assert!(!client.is_ttl_configs_frozen());
-}
-
-#[test]
-fn test_default_ttl_configurable_set_all() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &Some(persistent_cfg));
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(instance_cfg));
-    assert_eq!(persistent, Some(persistent_cfg));
-}
-
-#[test]
-fn test_default_ttl_configurable_set_partial() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-
-    // Only set instance config
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(instance_cfg));
-    assert!(persistent.is_none());
-}
-
-#[test]
-fn test_default_ttl_configurable_set_and_remove() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-
-    // Set config
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(instance_cfg));
-
-    // Remove by passing None
-    client.configurable_set_ttl_configs(&None, &None);
-    assert!(client.configurable_ttl_configs().0.is_none());
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Freeze Operations
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_freeze() {
-    let (_, _, client) = setup_contract();
-
-    assert!(!client.is_ttl_configs_frozen());
-    client.configurable_freeze_ttl_configs();
-    assert!(client.is_ttl_configs_frozen());
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1201)")]
-fn test_default_ttl_configurable_set_when_frozen() {
-    let (_, _, client) = setup_contract();
-
-    client.configurable_freeze_ttl_configs();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1202)")]
-fn test_default_ttl_configurable_freeze_when_already_frozen() {
-    let (_, _, client) = setup_contract();
-
-    client.configurable_freeze_ttl_configs();
-    client.configurable_freeze_ttl_configs();
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Validation
-// ============================================
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_invalid_instance_config() {
-    let (_, _, client) = setup_contract();
-    // threshold > extend_to is invalid
-    let invalid_cfg = TtlConfig::new(3000, 2000);
-    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_invalid_persistent_config() {
-    let (_, _, client) = setup_contract();
-    let invalid_cfg = TtlConfig::new(5000, 4000);
-    client.configurable_set_ttl_configs(&None, &Some(invalid_cfg));
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_exceeds_max_ttl() {
-    let (_, _, client) = setup_contract();
-    let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
-    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
-}
-
-#[test]
-fn test_default_ttl_configurable_invalid_does_not_partially_update() {
-    let (_, _, client) = setup_contract();
-
-    // Seed with an initial valid state.
-    let before_instance = TtlConfig::new(1000, 2000);
-    let before_persistent = TtlConfig::new(3000, 4000);
-    client.configurable_set_ttl_configs(&Some(before_instance), &Some(before_persistent));
-    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
-
-    // Attempt to update with one invalid config and one different valid config.
-    // This must fail and must not partially apply any changes.
-    let invalid_instance = TtlConfig::new(3000, 2000); // threshold > extend_to
-    let next_persistent = TtlConfig::new(3100, 4100);
-    assert_eq!(
-        client.try_configurable_set_ttl_configs(&Some(invalid_instance), &Some(next_persistent)).unwrap_err().unwrap(),
-        TtlError::InvalidTtlConfig.into()
-    );
-
-    // Ensure nothing changed.
-    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Boundary Values
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_at_max_ttl() {
-    let (env, _, client) = setup_contract();
-
-    // Get the effective max TTL
-    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
-
-    // extend_to == effective_max should be valid
-    let valid_cfg = TtlConfig::new(1000, effective_max);
-    client.configurable_set_ttl_configs(&Some(valid_cfg), &None);
-
-    let (instance, _) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(valid_cfg));
-}
-
-#[test]
-fn test_default_ttl_configurable_boundary_values() {
-    let (env, _, client) = setup_contract();
-
-    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
-
-    // Zero threshold and extend_to
-    let cfg = TtlConfig::new(0, 0);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-
-    // Zero threshold, max extend_to
-    let cfg = TtlConfig::new(0, effective_max);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-
-    // Equal threshold and extend_to
-    let cfg = TtlConfig::new(1000, 1000);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-}