test(dpp): cover state transitions, token config, perpetual distribution

packages/rs-dpp/src/data_contract/associated_token/token_configuration/methods/authorized_action_takers_for_configuration_item/v0/mod.rs

@@ -121,3 +121,229 @@ impl TokenConfigurationV0 {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::data_contract::associated_token::token_configuration::accessors::v0::{
+        TokenConfigurationV0Getters, TokenConfigurationV0Setters,
+    };
+    use crate::data_contract::associated_token::token_configuration_convention::v0::TokenConfigurationConventionV0;
+    use crate::data_contract::associated_token::token_configuration_convention::TokenConfigurationConvention;
+    use crate::data_contract::associated_token::token_marketplace_rules::v0::TokenTradeMode;
+    use crate::data_contract::change_control_rules::v0::ChangeControlRulesV0;
+    use crate::data_contract::change_control_rules::ChangeControlRules;
+    use platform_value::Identifier;
+
+    fn config_with_all_owner_rules() -> TokenConfigurationV0 {
+        let mut c = TokenConfigurationV0::default_most_restrictive();
+        // Assign each rule's authorized_to_make_change / admin_action_takers to a
+        // distinguishable value so we can verify dispatch.
+        let auth = AuthorizedActionTakers::ContractOwner;
+        let admin = AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]));
+        let rules = ChangeControlRules::V0(ChangeControlRulesV0 {
+            authorized_to_make_change: auth,
+            admin_action_takers: admin,
+            changing_authorized_action_takers_to_no_one_allowed: true,
+            changing_admin_action_takers_to_no_one_allowed: true,
+            self_changing_admin_action_takers_allowed: true,
+        });
+        c.set_conventions_change_rules(rules.clone());
+        c.set_max_supply_change_rules(rules.clone());
+        c.set_manual_minting_rules(rules.clone());
+        c.set_manual_burning_rules(rules.clone());
+        c.set_freeze_rules(rules.clone());
+        c.set_unfreeze_rules(rules.clone());
+        c.set_destroy_frozen_funds_rules(rules.clone());
+        c.set_emergency_action_rules(rules.clone());
+        c
+    }
+
+    #[test]
+    fn no_change_returns_no_one() {
+        let c = TokenConfigurationV0::default_most_restrictive();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::TokenConfigurationNoChange,
+        );
+        assert_eq!(result, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn conventions_item_returns_authorized_to_make_change() {
+        let c = config_with_all_owner_rules();
+        let conv = TokenConfigurationConvention::V0(TokenConfigurationConventionV0 {
+            localizations: Default::default(),
+            decimals: 8,
+        });
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::Conventions(conv),
+        );
+        assert_eq!(result, AuthorizedActionTakers::ContractOwner);
+    }
+
+    #[test]
+    fn conventions_control_group_returns_admin_action_takers() {
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::ConventionsControlGroup(AuthorizedActionTakers::NoOne),
+        );
+        // conventions_change_rules.admin_action_takers = Identity(9)
+        assert_eq!(
+            result,
+            AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]))
+        );
+    }
+
+    #[test]
+    fn conventions_admin_group_returns_admin_action_takers() {
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::ConventionsAdminGroup(AuthorizedActionTakers::NoOne),
+        );
+        assert_eq!(
+            result,
+            AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]))
+        );
+    }
+
+    #[test]
+    fn max_supply_returns_authorized_to_make_change() {
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MaxSupply(Some(42)),
+        );
+        assert_eq!(result, AuthorizedActionTakers::ContractOwner);
+    }
+
+    #[test]
+    fn max_supply_control_and_admin_return_admin() {
+        let c = config_with_all_owner_rules();
+        let expected = AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]));
+        let r1 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MaxSupplyControlGroup(AuthorizedActionTakers::NoOne),
+        );
+        let r2 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MaxSupplyAdminGroup(AuthorizedActionTakers::NoOne),
+        );
+        assert_eq!(r1, expected);
+        assert_eq!(r2, expected);
+    }
+
+    #[test]
+    fn manual_minting_returns_admin_not_authorized() {
+        // Note: ManualMinting in authorized_action_takers_for_configuration_item
+        // returns admin_action_takers (not authorized_to_make_change) per the
+        // implementation. Ensure that dispatch is correct.
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::ManualMinting(AuthorizedActionTakers::NoOne),
+        );
+        assert_eq!(
+            result,
+            AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]))
+        );
+    }
+
+    #[test]
+    fn freeze_returns_admin_action_takers() {
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::Freeze(AuthorizedActionTakers::NoOne),
+        );
+        assert_eq!(
+            result,
+            AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]))
+        );
+    }
+
+    #[test]
+    fn destroy_frozen_funds_returns_admin_action_takers() {
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::DestroyFrozenFunds(AuthorizedActionTakers::NoOne),
+        );
+        assert_eq!(
+            result,
+            AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]))
+        );
+    }
+
+    #[test]
+    fn main_control_group_always_returns_no_one() {
+        // Per implementation, MainControlGroup change items always return NoOne,
+        // regardless of config. This is important because modifying the main
+        // control group is governed by main_control_group_can_be_modified, not
+        // by any of the change_control_rules.
+        let c = config_with_all_owner_rules();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MainControlGroup(Some(3)),
+        );
+        assert_eq!(result, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn marketplace_trade_mode_returns_authorized_to_make_change() {
+        let c = TokenConfigurationV0::default_most_restrictive();
+        let result = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MarketplaceTradeMode(TokenTradeMode::NotTradeable),
+        );
+        // default rules are NoOne
+        assert_eq!(result, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn perpetual_distribution_returns_authorized_to_make_change() {
+        let c = TokenConfigurationV0::default_most_restrictive();
+        let r = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::PerpetualDistribution(None),
+        );
+        // default distribution rules authorized_to_make_change is NoOne
+        assert_eq!(r, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn new_tokens_destination_identity_returns_authorized_to_make_change() {
+        let c = TokenConfigurationV0::default_most_restrictive();
+        let r = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::NewTokensDestinationIdentity(None),
+        );
+        assert_eq!(r, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn minting_allow_choosing_destination_returns_authorized_to_make_change() {
+        let c = TokenConfigurationV0::default_most_restrictive();
+        let r = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::MintingAllowChoosingDestination(true),
+        );
+        assert_eq!(r, AuthorizedActionTakers::NoOne);
+    }
+
+    #[test]
+    fn unfreeze_and_admin_both_return_admin() {
+        let c = config_with_all_owner_rules();
+        let r1 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::Unfreeze(AuthorizedActionTakers::NoOne),
+        );
+        let r2 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::UnfreezeAdminGroup(AuthorizedActionTakers::NoOne),
+        );
+        let expected = AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]));
+        assert_eq!(r1, expected);
+        assert_eq!(r2, expected);
+    }
+
+    #[test]
+    fn emergency_action_and_admin_both_return_admin() {
+        let c = config_with_all_owner_rules();
+        let r1 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::EmergencyAction(AuthorizedActionTakers::NoOne),
+        );
+        let r2 = c.authorized_action_takers_for_configuration_item(
+            &TokenConfigurationChangeItem::EmergencyActionAdminGroup(AuthorizedActionTakers::NoOne),
+        );
+        let expected = AuthorizedActionTakers::Identity(Identifier::from([9u8; 32]));
+        assert_eq!(r1, expected);
+        assert_eq!(r2, expected);
+    }
+}